SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MSEdgeControl.cpp
Go to the documentation of this file.
1 /****************************************************************************/
10 // Stores edges and lanes, performs moving of vehicle
11 /****************************************************************************/
12 // SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
13 // Copyright (C) 2001-2012 DLR (http://www.dlr.de/) and contributors
14 /****************************************************************************/
15 //
16 // This file is part of SUMO.
17 // SUMO is free software: you can redistribute it and/or modify
18 // it under the terms of the GNU General Public License as published by
19 // the Free Software Foundation, either version 3 of the License, or
20 // (at your option) any later version.
21 //
22 /****************************************************************************/
23 
24 
25 // ===========================================================================
26 // included modules
27 // ===========================================================================
28 #ifdef _MSC_VER
29 #include <windows_config.h>
30 #else
31 #include <config.h>
32 #endif
33 
34 #include "MSEdgeControl.h"
35 #include "MSEdge.h"
36 #include "MSLane.h"
37 #include <iostream>
38 #include <vector>
39 
40 #ifdef CHECK_MEMORY_LEAKS
41 #include <foreign/nvwa/debug_new.h>
42 #endif // CHECK_MEMORY_LEAKS
43 
44 
45 // ===========================================================================
46 // member method definitions
47 // ===========================================================================
48 MSEdgeControl::MSEdgeControl(const std::vector< MSEdge* >& edges)
49  : myEdges(edges),
50  myLanes(MSLane::dictSize()),
51  myLastLaneChange(MSEdge::dictSize()) {
52  // build the usage definitions for lanes
53  for (std::vector< MSEdge* >::const_iterator i = myEdges.begin(); i != myEdges.end(); ++i) {
54  const std::vector<MSLane*>& lanes = (*i)->getLanes();
55  if (lanes.size() == 1) {
56  size_t pos = (*lanes.begin())->getNumericalID();
57  myLanes[pos].lane = *(lanes.begin());
58  myLanes[pos].firstNeigh = lanes.end();
59  myLanes[pos].lastNeigh = lanes.end();
60  myLanes[pos].amActive = false;
61  myLanes[pos].haveNeighbors = false;
62  } else {
63  for (std::vector<MSLane*>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
64  size_t pos = (*j)->getNumericalID();
65  myLanes[pos].lane = *j;
66  myLanes[pos].firstNeigh = (j + 1);
67  myLanes[pos].lastNeigh = lanes.end();
68  myLanes[pos].amActive = false;
69  myLanes[pos].haveNeighbors = true;
70  }
71  myLastLaneChange[(*i)->getNumericalID()] = -1;
72  }
73  }
74 }
75 
76 
78 }
79 
80 
81 void
83  for (std::set<MSLane*, Named::ComparatorIdLess>::iterator i = myChangedStateLanes.begin(); i != myChangedStateLanes.end(); ++i) {
84  LaneUsage& lu = myLanes[(*i)->getNumericalID()];
85  // if the lane was inactive but is now...
86  if (!lu.amActive && (*i)->getVehicleNumber() > 0) {
87  // ... add to active lanes and mark as such
88  if (lu.haveNeighbors) {
89  myActiveLanes.push_front(*i);
90  } else {
91  myActiveLanes.push_back(*i);
92  }
93  lu.amActive = true;
94  }
95  }
96  myChangedStateLanes.clear();
97 }
98 
99 void
101  for (std::list<MSLane*>::iterator i = myActiveLanes.begin(); i != myActiveLanes.end();) {
102  if ((*i)->getVehicleNumber() == 0 || (*i)->moveCritical(t)) {
103  myLanes[(*i)->getNumericalID()].amActive = false;
104  i = myActiveLanes.erase(i);
105  } else {
106  ++i;
107  }
108  }
109 }
110 
111 
112 void
114  myWithVehicles2Integrate.clear();
115  for (std::list<MSLane*>::iterator i = myActiveLanes.begin(); i != myActiveLanes.end();) {
116  if ((*i)->getVehicleNumber() == 0 || (*i)->setCritical(t, myWithVehicles2Integrate)) {
117  myLanes[(*i)->getNumericalID()].amActive = false;
118  i = myActiveLanes.erase(i);
119  } else {
120  ++i;
121  }
122  }
123  for (std::vector<MSLane*>::iterator i = myWithVehicles2Integrate.begin(); i != myWithVehicles2Integrate.end(); ++i) {
124  if ((*i)->integrateNewVehicle(t)) {
125  LaneUsage& lu = myLanes[(*i)->getNumericalID()];
126  if (!lu.amActive) {
127  if (lu.haveNeighbors) {
128  myActiveLanes.push_front(*i);
129  } else {
130  myActiveLanes.push_back(*i);
131  }
132  lu.amActive = true;
133  }
134  }
135  }
136 }
137 
138 
139 void
141  std::vector<MSLane*> toAdd;
142  for (std::list<MSLane*>::iterator i = myActiveLanes.begin(); i != myActiveLanes.end();) {
143  LaneUsage& lu = myLanes[(*i)->getNumericalID()];
144  if (lu.haveNeighbors) {
145  MSEdge& edge = (*i)->getEdge();
146  if (myLastLaneChange[edge.getNumericalID()] != t) {
147  myLastLaneChange[edge.getNumericalID()] = t;
148  edge.changeLanes(t);
149  const std::vector<MSLane*>& lanes = edge.getLanes();
150  for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
151  LaneUsage& lu = myLanes[(*i)->getNumericalID()];
152  if ((*i)->getVehicleNumber() > 0 && !lu.amActive) {
153  toAdd.push_back(*i);
154  lu.amActive = true;
155  }
156  }
157  }
158  ++i;
159  } else {
160  i = myActiveLanes.end();
161  }
162  }
163  for (std::vector<MSLane*>::iterator i = toAdd.begin(); i != toAdd.end(); ++i) {
164  myActiveLanes.push_front(*i);
165  }
166 }
167 
168 
169 void
171  // Detections is made by the edge's lanes, therefore hand over.
172  for (std::list<MSLane*>::iterator i = myActiveLanes.begin(); i != myActiveLanes.end(); ++i) {
173  (*i)->detectCollisions(timestep);
174  }
175 }
176 
177 
178 std::vector<std::string>
180  std::vector<std::string> ret;
181  for (std::vector<MSEdge*>::const_iterator i = myEdges.begin(); i != myEdges.end(); ++i) {
182  ret.push_back((*i)->getID());
183  }
184  return ret;
185 }
186 
187 
188 void
190  myChangedStateLanes.insert(l);
191 }
192 
193 
194 /****************************************************************************/
195