Eclipse SUMO - Simulation of Urban MObility
RONet.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2002-2022 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
21// The router's network representation
22/****************************************************************************/
23#pragma once
24#include <config.h>
25
26#include <vector>
32#include "ROLane.h"
33#include "RORoutable.h"
34#include "RORouteDef.h"
35
36#ifdef HAVE_FOX
38#endif
39
40
41// ===========================================================================
42// class declarations
43// ===========================================================================
44class ROEdge;
45class RONode;
46class ROPerson;
47class ROVehicle;
49class OptionsCont;
50class OutputDevice;
51
52
53// ===========================================================================
54// class definitions
55// ===========================================================================
62class RONet {
63public:
64
65 typedef std::map<const SUMOTime, std::vector<RORoutable*> > RoutablesMap;
66
68 RONet();
69
70
74 static RONet* getInstance();
75
76
78 virtual ~RONet();
79
80
86 void addRestriction(const std::string& id, const SUMOVehicleClass svc, const double speed);
87
88
94 const std::map<SUMOVehicleClass, double>* getRestrictions(const std::string& id) const;
95
96
98
99
100 /* @brief Adds a read edge to the network
101 *
102 * If the edge is already known (another one with the same id exists),
103 * an error is generated and given to msg-error-handler. The edge
104 * is deleted in this case and false is returned.
105 *
106 * @param[in] edge The edge to add
107 * @return Whether the edge was added (if not, it was deleted, too)
108 */
109 virtual bool addEdge(ROEdge* edge);
110
111
112 /* @brief Adds a district and connecting edges to the network
113 *
114 * If the district is already known (another one with the same id exists),
115 * an error is generated and given to msg-error-handler. The edges
116 * are deleted in this case and false is returned.
117 *
118 * @param[in] id The district to add
119 * @return Whether the district was added
120 */
121 bool addDistrict(const std::string id, ROEdge* source, ROEdge* sink);
122
123
124 /* @brief Adds a district and connecting edges to the network
125 *
126 * If the district is already known (another one with the same id exists),
127 * an error is generated and given to msg-error-handler. The edges
128 * are deleted in this case and false is returned.
129 *
130 * @param[in] id The district to add
131 * @return Whether the district was added
132 */
133 bool addDistrictEdge(const std::string tazID, const std::string edgeID, const bool isSource);
134
137
139 void setBidiEdges(const std::map<ROEdge*, std::string>& bidiMap);
140
145 const std::map<std::string, std::pair<std::vector<std::string>, std::vector<std::string> > >& getDistricts() const {
146 return myDistricts;
147 }
148
157 ROEdge* getEdge(const std::string& name) const {
158 return myEdges.get(name);
159 }
160
161
167 ROEdge* getEdgeForLaneID(const std::string& laneID) const;
168
174 ROLane* getLane(const std::string& laneID) const;
175
176 /* @brief Adds a read node to the network
177 *
178 * If the node is already known (another one with the same id exists),
179 * an error is generated and given to msg-error-handler. The node
180 * is deleted in this case
181 *
182 * @param[in] node The node to add
183 */
184 void addNode(RONode* node);
185
186
193 RONode* getNode(const std::string& id) const {
194 return myNodes.get(id);
195 }
196
197
198 /* @brief Adds a read stopping place (bus, train, container, parking) to the network
199 *
200 * If the place is already known (another one with the same id and category exists),
201 * an error is generated and given to msg-error-handler. The stop
202 * is deleted in this case
203 *
204 * @param[in] id The name of the stop to add
205 * @param[in] category The type of stop
206 * @param[in] stop The detailed stop description
207 */
208 void addStoppingPlace(const std::string& id, const SumoXMLTag category, SUMOVehicleParameter::Stop* stop);
209
216 const SUMOVehicleParameter::Stop* getStoppingPlace(const std::string& id, const SumoXMLTag category) const {
217 if (myStoppingPlaces.count(category) > 0) {
218 return myStoppingPlaces.find(category)->second.get(id);
219 }
220 return 0;
221 }
222
224 const std::string getStoppingPlaceName(const std::string& id) const;
225
227 const std::string getStoppingPlaceElement(const std::string& id) const;
229
230
231
233
234
241 bool checkVType(const std::string& id);
242
243
253 virtual bool addVehicleType(SUMOVTypeParameter* type);
254
255
269 bool addVTypeDistribution(const std::string& id, RandomDistributor<SUMOVTypeParameter*>* vehTypeDistribution);
270
271
282 SUMOVTypeParameter* getVehicleTypeSecure(const std::string& id);
283
284
285 /* @brief Adds a route definition to the network
286 *
287 * If the route definition is already known (another one with
288 * the same id exists), false is returned, but the route definition
289 * is not deleted.
290 *
291 * @param[in] def The route definition to add
292 * @return Whether the route definition could be added
293 * @todo Rename myRoutes to myRouteDefinitions
294 */
295 bool addRouteDef(RORouteDef* def);
296
297
305 RORouteDef* getRouteDef(const std::string& name) const {
306 return myRoutes.get(name);
307 }
308
309
310 /* @brief Adds a vehicle to the network
311 *
312 * If the vehicle is already known (another one with the same id
313 * exists), false is returned, but the vehicle is not deleted.
314 *
315 * Otherwise, the number of loaded routes ("myReadRouteNo") is increased.
316 *
317 * @param[in] id The id of the vehicle to add
318 * @param[in] veh The vehicle to add
319 * @return Whether the vehicle could be added
320 */
321 virtual bool addVehicle(const std::string& id, ROVehicle* veh);
322
324 bool knowsVehicle(const std::string& id) const;
325
327 SUMOTime getDeparture(const std::string& vehID) const;
328
329 /* @brief Adds a flow of vehicles to the network
330 *
331 * If the flow is already known (another one with the same id
332 * exists), false is returned, but the vehicle parameter are not deleted.
333 *
334 * Otherwise, the number of loaded routes ("myReadRouteNo") is increased.
335 *
336 * @param[in] flow The parameter of the flow to add
337 * @return Whether the flow could be added
338 */
339 bool addFlow(SUMOVehicleParameter* flow, const bool randomize);
340
341
342 /* @brief Adds a person to the network
343 *
344 * @param[in] person The person to add
345 */
346 bool addPerson(ROPerson* person);
347
348
349 /* @brief Adds a container to the network
350 *
351 * @param[in] depart The departure time of the container
352 * @param[in] desc The xml description of the container
353 */
354 void addContainer(const SUMOTime depart, const std::string desc);
355 // @}
356
357
359
360
373 const RORouterProvider& provider, SUMOTime time);
374
375
377 bool furtherStored();
379
380
387 void openOutput(const OptionsCont& options);
388
389
396 void writeIntermodal(const OptionsCont& options, ROIntermodalRouter& router) const;
397
398
400 void cleanup();
401
402
404 int getEdgeNumber() const;
405
407 int getInternalEdgeNumber() const;
408
410 return myEdges;
411 }
412
413 static void adaptIntermodalRouter(ROIntermodalRouter& router);
414
415 bool hasPermissions() const;
416
417 void setPermissionsFound();
418
420 bool hasBidiEdges() const {
421 return myHasBidiEdges;
422 }
423
425 bool hasLoadedEffort() const;
426
427 OutputDevice* getRouteOutput(const bool alternative = false) {
428 if (alternative) {
430 }
431 return myRoutesOutput;
432 }
433
434#ifdef HAVE_FOX
435 MFXWorkerThread::Pool& getThreadPool() {
436 return myThreadPool;
437 }
438
439 class WorkerThread : public MFXWorkerThread, public RORouterProvider {
440 public:
441 WorkerThread(MFXWorkerThread::Pool& pool,
442 const RORouterProvider& original)
443 : MFXWorkerThread(pool), RORouterProvider(original) {}
444 virtual ~WorkerThread() {
445 stop();
446 }
447 };
448
449 class BulkmodeTask : public MFXWorkerThread::Task {
450 public:
451 BulkmodeTask(const bool value) : myValue(value) {}
452 void run(MFXWorkerThread* context) {
453 static_cast<WorkerThread*>(context)->setBulkMode(myValue);
454 }
455 private:
456 const bool myValue;
457 private:
459 BulkmodeTask& operator=(const BulkmodeTask&);
460 };
461#endif
462
463
464private:
465 void checkFlows(SUMOTime time, MsgHandler* errorHandler);
466
467 void createBulkRouteRequests(const RORouterProvider& provider, const SUMOTime time, const bool removeLoops);
468
469private:
472
474 std::map<std::string, SUMOTime> myVehIDs;
475
477 std::set<std::string> myPersonIDs;
478
481
484
486 std::map<SumoXMLTag, NamedObjectCont<SUMOVehicleParameter::Stop*> > myStoppingPlaces;
487
490
492 typedef std::map< std::string, RandomDistributor<SUMOVTypeParameter*>* > VTypeDistDictType;
495
498
501
504
507
510
513
516
518 typedef std::multimap<const SUMOTime, const std::string> ContainerMap;
520
522 std::vector<const RORoutable*> myPTVehicles;
523
525 std::map<std::string, std::vector<SUMOTime> > myDepartures;
526
528 std::map<std::string, std::pair<std::vector<std::string>, std::vector<std::string> > > myDistricts;
529
532
535
538
541
544
547
550
552 std::map<std::string, std::map<SUMOVehicleClass, double> > myRestrictions;
553
556
559
561 const bool myKeepVTypeDist;
562
564 const bool myDoPTRouting;
565
568
569#ifdef HAVE_FOX
570private:
571 class RoutingTask : public MFXWorkerThread::Task {
572 public:
573 RoutingTask(RORoutable* v, const bool removeLoops, MsgHandler* errorHandler)
574 : myRoutable(v), myRemoveLoops(removeLoops), myErrorHandler(errorHandler) {}
575 void run(MFXWorkerThread* context);
576 private:
577 RORoutable* const myRoutable;
578 const bool myRemoveLoops;
580 private:
582 RoutingTask& operator=(const RoutingTask&);
583 };
584
585
586private:
588 MFXWorkerThread::Pool myThreadPool;
589#endif
590
591private:
593 RONet(const RONet& src);
594
596 RONet& operator=(const RONet& src);
597
598};
long long int SUMOTime
Definition: GUI.h:36
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
SumoXMLTag
Numbers representing SUMO-XML - element names.
A pool of worker threads which distributes the tasks and collects the results.
Abstract superclass of a task to be run with an index to keep track of pending tasks.
A thread repeatingly calculating incoming tasks.
T get(const std::string &id) const
Retrieves an item.
A storage for options typed value containers)
Definition: OptionsCont.h:89
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
Interface for building instances of router-edges.
A basic edge for routing applications.
Definition: ROEdge.h:70
A single lane the router may use.
Definition: ROLane.h:48
The router's network representation.
Definition: RONet.h:62
void createBulkRouteRequests(const RORouterProvider &provider, const SUMOTime time, const bool removeLoops)
Definition: RONet.cpp:592
SUMOVTypeParameter * getVehicleTypeSecure(const std::string &id)
Retrieves the named vehicle type.
Definition: RONet.cpp:353
static RONet * getInstance()
Returns the pointer to the unique instance of RONet (singleton).
Definition: RONet.cpp:56
int myNumInternalEdges
The number of internal edges in the dictionary.
Definition: RONet.h:555
bool myDefaultPedTypeMayBeDeleted
Whether the default pedestrian type was already used or can still be replaced.
Definition: RONet.h:500
bool hasBidiEdges() const
return whether the network contains bidirectional rail edges
Definition: RONet.h:420
void setPermissionsFound()
Definition: RONet.cpp:835
std::map< const SUMOTime, std::vector< RORoutable * > > RoutablesMap
Definition: RONet.h:65
bool myDefaultVTypeMayBeDeleted
Whether the default vehicle type was already used or can still be replaced.
Definition: RONet.h:497
void checkFlows(SUMOTime time, MsgHandler *errorHandler)
Definition: RONet.cpp:506
RONode * getNode(const std::string &id) const
Retrieves an node from the network.
Definition: RONet.h:193
const std::map< SUMOVehicleClass, double > * getRestrictions(const std::string &id) const
Returns the restrictions for an edge type If no restrictions are present, 0 is returned.
Definition: RONet.cpp:139
std::map< std::string, RandomDistributor< SUMOVTypeParameter * > * > VTypeDistDictType
Vehicle type distribution dictionary type.
Definition: RONet.h:492
ContainerMap myContainers
Definition: RONet.h:519
std::set< std::string > myPersonIDs
Known person ids.
Definition: RONet.h:477
std::map< std::string, std::pair< std::vector< std::string >, std::vector< std::string > > > myDistricts
traffic assignment zones with sources and sinks
Definition: RONet.h:528
bool addRouteDef(RORouteDef *def)
Definition: RONet.cpp:275
int myReadRouteNo
The number of read routes.
Definition: RONet.h:540
void addStoppingPlace(const std::string &id, const SumoXMLTag category, SUMOVehicleParameter::Stop *stop)
Definition: RONet.cpp:266
bool knowsVehicle(const std::string &id) const
returns whether a vehicle with the given id was already loaded
Definition: RONet.cpp:454
void cleanup()
closes the file output for computed routes and deletes associated threads if necessary
Definition: RONet.cpp:329
bool myHaveActiveFlows
whether any flows are still active
Definition: RONet.h:515
RONet(const RONet &src)
Invalidated copy constructor.
std::map< std::string, SUMOTime > myVehIDs
Known vehicle ids and their departure.
Definition: RONet.h:474
void openOutput(const OptionsCont &options)
Opens the output for computed routes.
Definition: RONet.cpp:281
NamedObjectCont< SUMOVehicleParameter * > myFlows
Known flows.
Definition: RONet.h:512
OutputDevice * myRouteAlternativesOutput
The file to write the computed route alternatives into.
Definition: RONet.h:534
bool myDefaultBikeTypeMayBeDeleted
Whether the default bicycle type was already used or can still be replaced.
Definition: RONet.h:503
RoutablesMap myRoutables
Known routables.
Definition: RONet.h:509
int getInternalEdgeNumber() const
Returns the number of internal edges the network contains.
Definition: RONet.cpp:765
virtual bool addVehicle(const std::string &id, ROVehicle *veh)
Definition: RONet.cpp:432
SUMOTime getDeparture(const std::string &vehID) const
returns departure time for the given vehicle id
Definition: RONet.cpp:459
OutputDevice * getRouteOutput(const bool alternative=false)
Definition: RONet.h:427
bool myHasBidiEdges
whether the network contains bidirectional railway edges
Definition: RONet.h:567
bool addDistrictEdge(const std::string tazID, const std::string edgeID, const bool isSource)
Definition: RONet.cpp:186
MsgHandler * myErrorHandler
handler for ignorable error messages
Definition: RONet.h:558
void writeIntermodal(const OptionsCont &options, ROIntermodalRouter &router) const
Writes the intermodal network and weights if requested.
Definition: RONet.cpp:310
RONet()
Constructor.
Definition: RONet.cpp:64
NamedObjectCont< RONode * > myNodes
Known nodes.
Definition: RONet.h:480
const std::string getStoppingPlaceElement(const std::string &id) const
return the element name for the given stopping place id
Definition: RONet.cpp:862
const SUMOVehicleParameter::Stop * getStoppingPlace(const std::string &id, const SumoXMLTag category) const
Retrieves a stopping place from the network.
Definition: RONet.h:216
void addContainer(const SUMOTime depart, const std::string desc)
Definition: RONet.cpp:500
static void adaptIntermodalRouter(ROIntermodalRouter &router)
Definition: RONet.cpp:784
ROEdge * getEdge(const std::string &name) const
Retrieves an edge from the network.
Definition: RONet.h:157
void addRestriction(const std::string &id, const SUMOVehicleClass svc, const double speed)
Adds a restriction for an edge type.
Definition: RONet.cpp:133
NamedObjectCont< RORouteDef * > myRoutes
Known routes.
Definition: RONet.h:506
bool furtherStored()
Returns the information whether further vehicles, persons or containers are stored.
Definition: RONet.cpp:753
bool checkVType(const std::string &id)
Checks whether the vehicle type (distribution) may be added.
Definition: RONet.cpp:383
OutputDevice * myRoutesOutput
The file to write the computed routes into.
Definition: RONet.h:531
bool addPerson(ROPerson *person)
Definition: RONet.cpp:488
int myWrittenRouteNo
The number of written routes.
Definition: RONet.h:546
static RONet * myInstance
Unique instance of RONet.
Definition: RONet.h:471
RORouteDef * getRouteDef(const std::string &name) const
Returns the named route definition.
Definition: RONet.h:305
SUMOTime saveAndRemoveRoutesUntil(OptionsCont &options, const RORouterProvider &provider, SUMOTime time)
Computes routes described by their definitions and saves them.
Definition: RONet.cpp:642
virtual bool addEdge(ROEdge *edge)
Definition: RONet.cpp:149
std::map< std::string, std::map< SUMOVehicleClass, double > > myRestrictions
The vehicle class specific speed restrictions.
Definition: RONet.h:552
std::map< SumoXMLTag, NamedObjectCont< SUMOVehicleParameter::Stop * > > myStoppingPlaces
Known bus / train / container stops and parking areas.
Definition: RONet.h:486
virtual bool addVehicleType(SUMOVTypeParameter *type)
Adds a read vehicle type definition to the network.
Definition: RONet.cpp:408
bool myHavePermissions
Whether the network contains edges which not all vehicles may pass.
Definition: RONet.h:549
bool hasPermissions() const
Definition: RONet.cpp:829
void setBidiEdges(const std::map< ROEdge *, std::string > &bidiMap)
add a taz for every junction unless a taz with the same id already exists
Definition: RONet.cpp:244
ROLane * getLane(const std::string &laneID) const
Retrieves a lane rom the network given it's id.
Definition: RONet.cpp:777
std::multimap< const SUMOTime, const std::string > ContainerMap
Known containers.
Definition: RONet.h:518
int myDiscardedRouteNo
The number of discarded routes.
Definition: RONet.h:543
const std::map< std::string, std::pair< std::vector< std::string >, std::vector< std::string > > > & getDistricts() const
Retrieves all TAZ (districts) from the network.
Definition: RONet.h:145
VTypeDistDictType myVTypeDistDict
A distribution of vehicle types (probability->vehicle type)
Definition: RONet.h:494
std::vector< const RORoutable * > myPTVehicles
vehicles to keep for public transport routing
Definition: RONet.h:522
NamedObjectCont< ROEdge * > myEdges
Known edges.
Definition: RONet.h:483
void addNode(RONode *node)
Definition: RONet.cpp:257
bool addVTypeDistribution(const std::string &id, RandomDistributor< SUMOVTypeParameter * > *vehTypeDistribution)
Adds a vehicle type distribution.
Definition: RONet.cpp:421
void addJunctionTaz(ROAbstractEdgeBuilder &eb)
add a taz for every junction unless a taz with the same id already exists
Definition: RONet.cpp:208
OutputDevice * myTypesOutput
The file to write the vehicle types into.
Definition: RONet.h:537
const bool myDoPTRouting
whether to calculate routes for public transport
Definition: RONet.h:564
const bool myKeepVTypeDist
whether to keep the the vtype distribution in output
Definition: RONet.h:561
virtual ~RONet()
Destructor.
Definition: RONet.cpp:105
const std::string getStoppingPlaceName(const std::string &id) const
return the name for the given stopping place id
Definition: RONet.cpp:850
std::map< std::string, std::vector< SUMOTime > > myDepartures
Departure times for randomized flows.
Definition: RONet.h:525
RONet & operator=(const RONet &src)
Invalidated assignment operator.
int getEdgeNumber() const
Returns the total number of edges the network contains including internal edges.
Definition: RONet.cpp:759
const NamedObjectCont< ROEdge * > & getEdgeMap() const
Definition: RONet.h:409
ROEdge * getEdgeForLaneID(const std::string &laneID) const
Retrieves an edge from the network when the lane id is given.
Definition: RONet.cpp:771
bool addFlow(SUMOVehicleParameter *flow, const bool randomize)
Definition: RONet.cpp:470
bool hasLoadedEffort() const
whether efforts were loaded from file
Definition: RONet.cpp:840
NamedObjectCont< SUMOVTypeParameter * > myVehicleTypes
Known vehicle types.
Definition: RONet.h:489
bool addDistrict(const std::string id, ROEdge *source, ROEdge *sink)
Definition: RONet.cpp:163
Base class for nodes used by the router.
Definition: RONode.h:43
A person as used by router.
Definition: ROPerson.h:49
A routable thing such as a vehicle or person.
Definition: RORoutable.h:52
Base class for a vehicle's route definition.
Definition: RORouteDef.h:53
A vehicle as used by router.
Definition: ROVehicle.h:50
Structure representing possible vehicle parameter.
Definition of vehicle stop (position and duration)
Structure representing possible vehicle parameter.
@ value
the parser finished reading a JSON value