53 #include <mesosim/MELoop.h>
54 #include <mesosim/MESegment.h>
55 #include <mesosim/MEVehicle.h>
58 #ifdef CHECK_MEMORY_LEAKS
60 #endif // CHECK_MEMORY_LEAKS
75 const std::string& streetName,
76 const std::string& edgeType,
78 Named(id), myNumericalID(numericalID), myLanes(0),
79 myLaneChanger(0), myFunction(function), myVaporizationRequests(0),
80 myLastFailedInsertionTime(-1),
81 myFromJunction(0), myToJunction(0),
82 myStreetName(streetName),
86 myEmptyTraveltime(-1.),
88 myAmRoundabout(false) {}
97 for (AllowedLanesCont::iterator i1 = (*i2).second.begin(); i1 != (*i2).second.end(); i1++) {
110 if (!lanes->empty()) {
130 myAllowed[0] =
new std::vector<MSLane*>();
131 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
134 for (MSLinkCont::const_iterator j = lc.begin(); j != lc.end(); ++j) {
135 MSLane* toL = (*j)->getLane();
147 myAllowed[&to] =
new std::vector<MSLane*>();
151 #ifdef HAVE_INTERNAL_LANES
152 toL = (*j)->getViaLane();
172 for (AllowedLanesCont::iterator i1 = (*i2).second.begin(); i1 != (*i2).second.end(); i1++) {
181 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
204 if (index == (
int)
myLanes->size()) {
207 const int resultIndex = index + offset;
208 if (resultIndex >= (
int)
myLanes->size() || resultIndex < 0) {
211 return (*
myLanes)[resultIndex];
216 const std::vector<MSLane*>*
222 const std::vector<MSLane*>*
228 const std::vector<MSLane*>*
230 AllowedLanesCont::const_iterator it = c.find(dest);
238 const std::vector<MSLane*>*
253 for (AllowedLanesCont::const_iterator i1 =
myAllowed.begin(); i1 !=
myAllowed.end(); ++i1) {
254 const MSEdge* edge = i1->first;
255 const std::vector<MSLane*>* lanes = i1->second;
258 for (std::vector<MSLane*>::const_iterator i2 = lanes->begin(); i2 != lanes->end(); ++i2) {
260 if ((*i2)->allowsVehicleClass(vclass)) {
299 for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i) {
300 const SUMOReal occupancy = (*i)->getBruttoOccupancy();
301 if (occupancy < leastOccupancy) {
303 leastOccupancy = occupancy;
331 const std::vector<MSVehicle::LaneQ>& bl = veh.
getBestLanes();
333 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
334 if ((*i).length > bestLength) {
335 bestLength = (*i).length;
338 std::vector<MSLane*>* bestLanes =
new std::vector<MSLane*>();
339 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
340 if ((*i).length == bestLength) {
341 bestLanes->push_back((*i).lane);
350 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
376 WRITE_WARNING(
"Choosing new speed factor for vehicle '" + pars.
id +
"' to match departure speed.");
380 "' is too high for the departure edge '" +
getID() +
"'.");
395 v.
getID() +
"'. Inserting at lane end instead.");
407 MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*
this, pos);
408 MEVehicle* veh =
static_cast<MEVehicle*
>(&v);
410 while (segment != 0 && !result) {
412 result = segment->hasSpaceFor(veh, time,
true);
414 result = segment->initialise(veh, time);
416 segment = segment->getNextSegment();
420 result = segment->hasSpaceFor(veh, time,
true);
422 result = segment->initialise(veh, time);
442 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
443 const SUMOReal occupancy = (*i)->getBruttoOccupancy();
452 return insertionLane != 0 && insertionLane->
insertVehicle(static_cast<MSVehicle&>(v));
463 for (std::vector<MSLane*>::const_iterator it =
myLanes->begin(); it !=
myLanes->end(); ++it) {
477 #ifdef HAVE_INTERNAL_LANES
479 MSEdge::getInternalFollowingEdge(
MSEdge* followerAfterInternal)
const {
481 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
484 for (MSLinkCont::const_iterator j = lc.begin(); j != lc.end(); ++j) {
487 if (link->getViaLane() != 0) {
488 return &link->getViaLane()->getEdge();
502 assert(minSpeed > 0);
509 MESegment* first = MSGlobals::gMesoNet->getSegmentForEdge(*
this);
510 unsigned segments = 0;
512 v += first->getMeanSpeed();
513 first = first->getNextSegment();
515 }
while (first != 0);
519 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
520 v += (*i)->getMeanSpeed();
532 DictType::iterator it =
myDict.find(
id);
548 DictType::iterator it =
myDict.find(
id);
578 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
587 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
588 into.push_back((*i).first);
595 const std::string& rid) {
597 std::istringstream in(desc, std::ios::binary);
610 const std::string& rid) {
611 for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
615 throw ProcessError(
"The edge '" + *i +
"' within the route " + rid +
" is not known."
616 +
"\n The route can not be build.");
618 into.push_back(edge);
636 return getLanes()[0]->getSpeedLimit();
643 return getLanes()[0]->getVehicleMaxSpeed(veh);
647 std::vector<MSPerson*>
655 std::vector<MSContainer*>
695 const std::vector<MSLane*>* allowed =
allowedLanes(*it, vClass);
696 if (allowed == 0 || allowed->size() > 0) {
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
const std::string & getID() const
returns the person id
std::set< MSPerson * > myPersons
Persons on the edge (only for drawing)
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)
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
Sorts edges by their ids.
bool insertVehicle(SUMOVehicle &v, SUMOTime time, const bool checkOnly=false) const
Tries to insert the given vehicle into the network.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
SUMOReal getDistanceTo(const MSEdge *other) const
optimistic air distance heuristic for use in routing
static size_t numericalDictSize()
Returns the number of edges with a numerical id.
void initialize(const std::vector< MSLane * > *lanes)
Initialize the edge.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
SUMOReal getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
virtual SUMOReal getEdgePos(SUMOTime now) const =0
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
void recalcCache()
Recalculates the cached values.
SUMOReal departSpeed
(optional) The initial speed of the vehicle
static MSEdgeVector myEdges
Static list of edges.
const EdgeBasicFunction myFunction
the purpose of the edge
ClassesSuccesorMap myClassesSuccessorMap
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.
int operator()(const MSContainer *const c1, const MSContainer *const c2) const
comparing operator
The least occupied lane is used.
static SUMOReal rand()
Returns a random real number in [0, 1)
virtual ~MSEdge()
Destructor.
const MSRoute & getRoute() const
Returns the current route.
SUMOReal computeChosenSpeedDeviation(MTRand *rng, const SUMOReal minDevFactor=0.2) const
Computes and returns the speed deviation.
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...
SUMOTime incVaporization(SUMOTime t)
Enables vaporization.
MSLane * getFreeLane(const std::vector< MSLane * > *allowed, const SUMOVehicleClass vclass) const
Finds the emptiest lane allowing the vehicle class.
The lane is chosen randomly.
std::vector< const MSEdge * > ConstMSEdgeVector
std::vector< MSContainer * > getSortedContainers(SUMOTime timestep) const
Returns this edge's containers sorted by pos.
static T getRandomFrom(const std::vector< T > &v)
Returns a random element from the given vector.
const SVCPermissions SVCAll
int myVaporizationRequests
Vaporizer counter.
EdgeBasicFunction
Defines possible edge types.
The least occupied lane from best lanes.
The position is chosen randomly.
SUMOTime decVaporization(SUMOTime t)
Disables vaporization.
#define UNUSED_PARAMETER(x)
MSContainerStage * getCurrentStage() const
Return the current stage.
#define WRITE_WARNING(msg)
std::map< std::string, MSEdge * > DictType
definition of the static dictionary type
The car-following model and parameter.
static OptionsCont & getOptions()
Retrieves the options.
Performs lane changing of vehicles.
const std::string & getID() const
Returns the id.
A road/street connecting two junctions.
bool insertVehicle(MSVehicle &v)
Tries to insert the given vehicle.
void rebuildAllowedLanes()
Sorts persons by their positions.
SUMOReal getLength() const
return the length of the edge
MSLane * getLogicalPredecessorLane() const
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
SUMOReal getSpeedDeviation() const
Returns this type's speed deviation.
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.
AllowedLanesCont myAllowed
Associative container from destination-edge to allowed-lanes.
MSLane * getLane() const
Returns the connected lane.
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.
MSPersonStage * getCurrentStage() const
MSEdgeVector mySuccessors
The succeeding edges.
MSLane * leftLane(const MSLane *const lane) const
Returns the lane left to the one given, 0 if the given lane is leftmost.
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.
bool isVaporizing() const
Returns whether vehicles on this edge shall be vaporized.
int operator()(const MSPerson *const p1, const MSPerson *const p2) const
comparing operator
const std::vector< MSLane * > * myLanes
Container for the edge's lane; should be sorted: (right-hand-traffic) the more left the lane...
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
SUMOReal getSpeedLimit() const
Returns the speed limit of the edge The speed limit of the first lane is retured; should probably be...
If a fixed number of random choices fails, a free position is chosen.
const std::vector< LaneQ > & getBestLanes() const
Returns the description of best lanes to use in order to continue the route.
MSLane * getDepartLane(MSVehicle &veh) const
Finds a depart lane for the given vehicle parameters.
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)
virtual SUMOReal getEdgePos(SUMOTime now) const =0
std::vector< std::string > getVector()
SVCPermissions myCombinedPermissions
The union of lane permissions for this edge.
SUMOReal getSpeedFactor() const
Returns this type's speed factor.
No information given; use default.
EdgeBasicFunction getPurpose() const
Returns the edge type (EdgeBasicFunction)
Sorts containers by their positions.
Structure representing possible vehicle parameter.
bool havePriority() const
Returns whether this link is a major link.
std::set< MSContainer * > myContainers
Containers on the edge.
int getNumericalID() const
Returns the numerical id of the edge.
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...
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...
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)
SUMOReal myEmptyTraveltime
the traveltime on the empty edge (cached value for speedup)
const std::vector< MSLane * > * allowedLanes(const MSEdge &destination, SUMOVehicleClass vclass=SVC_IGNORING) const
Get the allowed lanes to reach the destination-edge.
static size_t dictSize()
Returns the number of edges.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
const std::string & getID() const
returns the container id
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
SUMOReal departPos
(optional) The position the vehicle shall depart from
std::map< const MSEdge *, std::vector< MSLane * > * > AllowedLanesCont
Suceeding edges (keys) and allowed lanes to reach these edges (values).
unsigned size() const
Returns the number of edges to pass.
SUMOReal distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
static DictType myDict
Static dictionary to associate string-ids with objects.
static void readEdgeVector(std::istream &in, std::vector< const E * > &edges, const std::string &rid)
Reads an edge vector binary.
static const bool gUseMesoSim
const MSJunction * getFromJunction() const
const MSEdgeVector & getSuccessors() const
Returns the following edges.
SUMOReal getVehicleMaxSpeed(const SUMOVehicle *const veh) const
Returns the maximum speed the vehicle may use on this edge.
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
A free position is chosen.
std::vector< MSEdge * > MSEdgeVector
MSLane * rightLane(const MSLane *const lane) const
Returns the lane right to the one given, 0 if the given lane is rightmost.
The edge is an internal edge.
const std::vector< MSLane * > * getAllowedLanesWithDefault(const AllowedLanesCont &c, const MSEdge *dest) const
lookup in map and return 0 if not found
SUMOReal getBruttoOccupancy() const
Returns the brutto (including minGaps) occupancy of this lane during the last step.
std::vector< MSPerson * > getSortedPersons(SUMOTime timestep) const
Returns this edge's persons sorted by pos.
MSEdgeVector myPredecessors
The preceeding edges.
Representation of a lane in the micro simulation.
SUMOReal getCurrentTravelTime(const SUMOReal minSpeed=NUMERICAL_EPS) const
Computes and returns the current travel time for this edge.
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.
vehicles ignoring classes
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
std::string id
The vehicle's id.
const MSJunction * getToJunction() const
const Position & getPosition() const
virtual const MSVehicleType & getVehicleType() const =0
Returns the vehicle's type.