60 #ifdef CHECK_MEMORY_LEAKS 62 #endif // CHECK_MEMORY_LEAKS 77 const std::string& streetName,
78 const std::string& edgeType,
80 Named(id), myNumericalID(numericalID), myLanes(0),
81 myLaneChanger(0), myFunction(function), myVaporizationRequests(0),
82 myLastFailedInsertionTime(-1),
83 myFromJunction(0), myToJunction(0),
84 myStreetName(streetName),
89 myEmptyTraveltime(-1.),
91 myAmRoundabout(false) {}
100 for (AllowedLanesCont::iterator i1 = (*i2).second.begin(); i1 != (*i2).second.end(); i1++) {
113 if (!lanes->empty()) {
119 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
124 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
125 (*i)->setRightSideOnEdge(widthBefore, (
int)
mySublaneSides.size());
130 widthBefore += (*i)->getWidth();
146 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
149 for (MSLinkCont::const_iterator j = lc.begin(); j != lc.end(); ++j) {
151 if (minPenalty == -1) {
158 if (minPenalty > 0) {
167 myAllowed[0] =
new std::vector<MSLane*>();
168 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
171 for (MSLinkCont::const_iterator j = lc.begin(); j != lc.end(); ++j) {
172 (*j)->initParallelLinks();
173 MSLane* toL = (*j)->getLane();
185 myAllowed[&to] =
new std::vector<MSLane*>();
189 #ifdef HAVE_INTERNAL_LANES 190 toL = (*j)->getViaLane();
232 for (std::vector<MSLane*>::const_iterator it =
myLanes->begin(); it !=
myLanes->end(); ++it) {
255 for (AllowedLanesCont::iterator i1 = (*i2).second.begin(); i1 != (*i2).second.end(); i1++) {
264 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
287 if (index == (
int)
myLanes->size()) {
290 const int resultIndex = index + offset;
291 if (resultIndex >= (
int)
myLanes->size() || resultIndex < 0) {
294 return (*
myLanes)[resultIndex];
299 const std::vector<MSLane*>*
305 const std::vector<MSLane*>*
311 const std::vector<MSLane*>*
313 AllowedLanesCont::const_iterator it = c.find(dest);
321 const std::vector<MSLane*>*
337 if (MSDevice_Routing::isParallel()) {
338 MSDevice_Routing::lock();
341 for (AllowedLanesCont::const_iterator i1 =
myAllowed.begin(); i1 !=
myAllowed.end(); ++i1) {
342 const MSEdge* edge = i1->first;
343 const std::vector<MSLane*>* lanes = i1->second;
346 for (std::vector<MSLane*>::const_iterator i2 = lanes->begin(); i2 != lanes->end(); ++i2) {
348 if ((*i2)->allowsVehicleClass(vclass)) {
354 for (MSLinkCont::const_iterator it_link = lc.begin(); it_link != lc.end(); ++it_link) {
355 const MSLane* targetLane = (*it_link)->getLane();
372 if (MSDevice_Routing::isParallel()) {
373 MSDevice_Routing::unlock();
404 for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i) {
405 const SUMOReal occupancy = (*i)->getBruttoOccupancy();
406 if (occupancy < leastOccupancy) {
408 leastOccupancy = occupancy;
436 const std::vector<MSVehicle::LaneQ>& bl = veh.
getBestLanes();
438 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
439 if ((*i).length > bestLength) {
440 bestLength = (*i).length;
443 std::vector<MSLane*>* bestLanes =
new std::vector<MSLane*>();
444 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
445 if ((*i).length == bestLength) {
446 bestLanes->push_back((*i).lane);
455 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
477 if (
isTaz() && checkOnly) {
491 "' is too high for the departure edge '" +
getID() +
"'.");
500 WRITE_WARNING(
"Removing vehicle '" + pars.
id +
"' which has no valid route.");
517 v.
getID() +
"'. Inserting at lane end instead.");
532 while (segment != 0 && !result) {
555 if (insertionLane == 0) {
563 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
564 const SUMOReal occupancy = (*i)->getBruttoOccupancy();
573 return insertionLane != 0 && insertionLane->
insertVehicle(static_cast<MSVehicle&>(v));
585 for (std::vector<MSLane*>::const_iterator it =
myLanes->begin(); it !=
myLanes->end(); ++it) {
605 #ifdef HAVE_INTERNAL_LANES 607 MSEdge::getInternalFollowingEdge(
const MSEdge* followerAfterInternal)
const {
609 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
612 for (MSLinkCont::const_iterator j = lc.begin(); j != lc.end(); ++j) {
615 if (link->getViaLane() != 0) {
616 return &link->getViaLane()->getEdge();
635 v += vehNo * segment->getMeanSpeed();
642 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
644 v += vehNo * (*i)->getMeanSpeed();
657 assert(minSpeed > 0);
674 DictType::iterator it =
myDict.find(
id);
690 DictType::iterator it =
myDict.find(
id);
701 return (
int)
myDict.size();
713 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
722 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
723 into.push_back((*i).first);
730 const std::string& rid) {
732 std::istringstream in(desc, std::ios::binary);
745 const std::string& rid) {
746 for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
750 throw ProcessError(
"The edge '" + *i +
"' within the route " + rid +
" is not known." 751 +
"\n The route can not be build.");
753 into.push_back(edge);
771 return getLanes()[0]->getSpeedLimit();
778 return getLanes()[0]->getVehicleMaxSpeed(veh);
785 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
786 (*i)->setMaxSpeed(val);
793 std::vector<MSTransportable*>
801 std::vector<MSTransportable*>
825 if (MSDevice_Routing::isParallel()) {
826 MSDevice_Routing::lock();
837 i->second.push_back(*it);
839 const std::vector<MSLane*>* allowed =
allowedLanes(*it, vClass);
840 if (allowed != 0 && allowed->size() > 0) {
841 i->second.push_back(*it);
848 if (MSDevice_Routing::isParallel()) {
849 MSDevice_Routing::unlock();
static const T & getRandomFrom(const std::vector< T > &v)
Returns a random element from the given vector.
void laneChange(SUMOTime t)
Start lane-change-process for all vehicles on the edge'e lanes.
bool myAmDelayed
whether this edge had a vehicle with less than max speed on it
bool insertVehicle(SUMOVehicle &v, SUMOTime time, const bool checkOnly=false) const
Tries to insert the given vehicle into the network.
SUMOReal getCurrentTravelTime(const SUMOReal minSpeed=NUMERICAL_EPS) const
Computes and returns the current travel time for this edge.
MESegment * getNextSegment() const
Returns the following segment on the same edge (0 if it is the last).
MSLane * getLogicalPredecessorLane() const
get the most likely precedecessor lane (sorted using by_connections_to_sorter). The result is cached ...
bool allowsLaneChanging()
std::set< MSTransportable * > myContainers
Containers on the edge.
MSEdge & getEdge() const
Returns the lane's edge.
Representation of a vehicle in the micro simulation.
static void insertIDs(std::vector< std::string > &into)
Inserts IDs of all known edges into the given vector.
SUMOReal myLength
the length of the edge (cached value for speedup)
void descheduleDeparture(SUMOVehicle *veh)
stops trying to emit the given vehicle (and delete it)
Sorts edges by their ids.
SUMOReal getSpeedDeviation() const
Returns this type's speed deviation.
A vehicle from the mesoscopic point of view.
MSLane * parallelLane(const MSLane *const lane, int offset) const
Returns the lane with the given offset parallel to the given lane one or 0 if it does not exist...
MSLane * getLane() const
Returns the connected lane.
SUMOTime getMesoTLSPenalty() const
Returns the time penalty for passing a tls-controlled link (meso)
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
static int dictSize()
Returns the number of edges.
bool initialise(MEVehicle *veh, SUMOTime time)
Inserts (emits) vehicle into the segment.
static void readEdgeVector(std::istream &in, std::vector< const E *> &edges, const std::string &rid)
Reads an edge vector binary.
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
void recalcCache()
Recalculates the cached values.
This is an uncontrolled, minor link, has to stop.
SUMOReal departSpeed
(optional) The initial speed of the vehicle
static MSEdgeVector myEdges
Static list of edges.
const EdgeBasicFunction myFunction
the purpose of the edge
ClassedAllowedLanesCont myClassedAllowed
From vehicle class to lanes allowed to be used by it.
virtual const MSEdge * getEdge() const =0
Returns the edge the vehicle is currently at.
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
The least occupied lane is used.
virtual SUMOReal getEdgePos(SUMOTime now) const =0
void buildSegmentsFor(const MSEdge &e, const OptionsCont &oc)
Build the segments for a given edge.
static SUMOReal rand()
Returns a random real number in [0, 1)
std::string time2string(SUMOTime t)
virtual ~MSEdge()
Destructor.
const std::vector< MSLane * > * allowedLanes(const MSEdge &destination, SUMOVehicleClass vclass=SVC_IGNORING) const
Get the allowed lanes to reach the destination-edge.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
const MSRoute & getRoute() const
Returns the current route.
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...
This is an uncontrolled, right-before-left link.
SUMOTime incVaporization(SUMOTime t)
Enables vaporization.
The lane is chosen randomly.
std::vector< const MSEdge * > ConstMSEdgeVector
void initialize(const std::vector< MSLane *> *lanes)
Initialize the edge.
const std::string & getID() const
Returns the id.
const SVCPermissions SVCAll
int myVaporizationRequests
Vaporizer counter.
EdgeBasicFunction
Defines possible edge types.
int operator()(const MSTransportable *const c1, const MSTransportable *const c2) const
comparing operator
int size() const
Returns the number of edges to pass.
const MSJunction * getToJunction() const
The least occupied lane from best lanes.
The position is chosen randomly.
SUMOTime decVaporization(SUMOTime t)
Disables vaporization.
int getNumericalID() const
Returns the numerical id of the edge.
This is an uncontrolled, all-way stop link.
std::vector< MSTransportable * > getSortedContainers(SUMOTime timestep) const
Returns this edge's containers sorted by pos.
SUMOReal getDistanceTo(const MSEdge *other) const
optimistic air distance heuristic for use in routing
This is an uncontrolled, zipper-merge link.
#define WRITE_WARNING(msg)
std::map< std::string, MSEdge *> DictType
definition of the static dictionary type
The car-following model and parameter.
bool isVaporizing() const
Returns whether vehicles on this edge shall be vaporized.
static OptionsCont & getOptions()
Retrieves the options.
Performs lane changing of vehicles.
LinkState getState() const
Returns the current state of the link.
SUMOReal getSpeedLimit() const
Returns the speed limit of the edge The speed limit of the first lane is retured; should probably be...
bool hasSpaceFor(const MEVehicle *veh, SUMOTime entryTime, bool init=false) const
Returns whether the given vehicle would still fit into the segment.
SUMOReal distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
virtual SUMOReal getChosenSpeedFactor() const =0
Performs lane changing of vehicles.
A road/street connecting two junctions.
bool insertVehicle(MSVehicle &v)
Tries to insert the given vehicle.
SUMOReal getVehicleMaxSpeed(const SUMOVehicle *const veh) const
Returns the maximum speed the vehicle may use on this edge.
MSTransportable::Stage * getCurrentStage() const
Return the current stage.
std::map< SUMOVehicleClass, MSEdgeVector > myClassesSuccessorMap
The successors available for a given vClass.
void rebuildAllowedLanes()
SUMOReal computeChosenSpeedDeviation(MTRand *rng, const SUMOReal minDevFactor=0.2) const
Computes and returns the speed deviation.
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
The edge is a district edge.
virtual void setChosenSpeedFactor(const SUMOReal factor)=0
Representation of a vehicle.
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
The least occupied lane from lanes which allow the continuation.
This is an uncontrolled, minor link, has to brake.
AllowedLanesCont myAllowed
Associative container from destination-edge to allowed-lanes.
virtual bool hasValidRoute(std::string &msg, const MSRoute *route=0) const =0
Validates the current or given route.
void updateBestLanes(bool forceRebuild=false, const MSLane *startLane=0)
computes the best lanes to use in order to continue the route
static void clear()
Clears the dictionary.
SVCPermissions myMinimumPermissions
The intersection of lane permissions for this edge.
SUMOReal getSpeedFactor() const
Returns this type's speed factor.
MSLane * getFreeLane(const std::vector< MSLane *> *allowed, const SUMOVehicleClass vclass) const
Finds the emptiest lane allowing the vehicle class.
MSEdgeVector mySuccessors
The succeeding edges.
SUMOReal getRoutingSpeed() const
Returns the averaged speed used by the routing device.
MSLaneChanger * myLaneChanger
This member will do the lane-change.
MSEdge(const std::string &id, int numericalID, const EdgeBasicFunction function, const std::string &streetName, const std::string &edgeType, int priority)
Constructor.
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic, in MSLink and GNEInternalLane.
MSLane * leftLane(const MSLane *const lane) const
Returns the lane left to the one given, 0 if the given lane is leftmost.
const Position & getPosition() const
const std::string & getID() const
returns the id of the transportable
MSLane * getDepartLane(MSVehicle &veh) const
Finds a depart lane for the given vehicle parameters.
std::vector< SUMOReal > mySublaneSides
the right side for each sublane on this edge
const std::vector< MSLane * > * myLanes
Container for the edge's lane; should be sorted: (right-hand-traffic) the more left the lane...
EdgeBasicFunction getPurpose() const
Returns the edge type (EdgeBasicFunction)
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
If a fixed number of random choices fails, a free position is chosen.
bool canChangeToOpposite()
whether this edge allows changing to the opposite direction edge
Base class for objects which have an id.
The rightmost lane the vehicle may use.
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
SUMOReal getBruttoOccupancy() const
Returns the brutto (including minGaps) occupancy of this lane during the last step.
std::vector< std::string > getVector()
SVCPermissions myCombinedPermissions
The union of lane permissions for this edge.
No information given; use default.
void buildLaneChanger()
Has to be called after all sucessors and predecessors have been set (after closeBuilding()) ...
static SUMOReal getAssumedSpeed(const MSEdge *edge)
return current travel speed assumption
Structure representing possible vehicle parameter.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
static MSLink * getConnectingLink(const MSLane &from, const MSLane &to)
Returns the link connecting both lanes Both lanes have to be non-internal; 0 may be returned if no co...
MSInsertionControl & getInsertionControl()
Returns the insertion control.
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
virtual void changeLanes(SUMOTime t)
Performs lane changing on this edge.
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
const MSJunction * getFromJunction() const
SUMOReal myEmptyTraveltime
the traveltime on the empty edge (cached value for speedup)
A single mesoscopic segment (cell)
SUMOReal getMeanSpeed() const
get the mean speed
SUMOReal getLength() const
return the length of the edge
static SUMOReal gLateralResolution
MESegment * getSegmentForEdge(const MSEdge &e, SUMOReal pos=0)
Get the segment for a given edge at a given position.
const MSEdgeVector & getSuccessors() const
Returns the following edges.
static MELoop * gMesoNet
mesoscopic simulation infrastructure
SUMOReal departPos
(optional) The position the vehicle shall depart from
void setMaxSpeed(SUMOReal val) const
Sets a new maximum speed for all lanes (used by TraCI and MSCalibrator)
bool allowsVehicleClass(SUMOVehicleClass vclass) const
std::map< const MSEdge *, std::vector< MSLane * > *> AllowedLanesCont
Suceeding edges (keys) and allowed lanes to reach these edges (values).
static DictType myDict
Static dictionary to associate string-ids with objects.
Sorts transportables by their positions.
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
A free position is chosen.
std::vector< MSEdge * > MSEdgeVector
SUMOReal myWidth
Edge width [m].
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
const std::vector< LaneQ > & getBestLanes() const
Returns the description of best lanes to use in order to continue the route.
std::vector< MSTransportable * > getSortedPersons(SUMOTime timestep) const
Returns this edge's persons sorted by pos.
static SUMOReal gMesoTLSPenalty
The edge is an internal edge.
static SUMOTime gLaneChangeDuration
MSEdgeVector myPredecessors
The preceeding edges.
Representation of a lane in the micro simulation.
MSLane * rightLane(const MSLane *const lane) const
Returns the lane right to the one given, 0 if the given lane is rightmost.
static void parseEdgesList(const std::string &desc, ConstMSEdgeVector &into, const std::string &rid)
Parses the given string assuming it contains a list of edge ids divided by spaces.
virtual const std::string & getID() const =0
Get the vehicle's ID.
const std::vector< MSLane * > * getAllowedLanesWithDefault(const AllowedLanesCont &c, const MSEdge *dest) const
lookup in map and return 0 if not found
vehicles ignoring classes
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
SUMOReal getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
std::string id
The vehicle's id.
std::set< MSTransportable * > myPersons
Persons on the edge for drawing and pushbutton.
virtual const MSVehicleType & getVehicleType() const =0
Returns the vehicle's type.