Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
RONet.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2002-2024 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
53
54// ===========================================================================
55// class definitions
56// ===========================================================================
63class RONet {
64public:
65
66 typedef std::map<const SUMOTime, std::vector<RORoutable*> > RoutablesMap;
67
69 RONet();
70
71
75 static RONet* getInstance();
76
77
79 virtual ~RONet();
80
81
87 void addRestriction(const std::string& id, const SUMOVehicleClass svc, const double speed);
88
89
95 const std::map<SUMOVehicleClass, double>* getRestrictions(const std::string& id) const;
96
97
99
100
101 /* @brief Adds a read edge to the network
102 *
103 * If the edge is already known (another one with the same id exists),
104 * an error is generated and given to msg-error-handler. The edge
105 * is deleted in this case and false is returned.
106 *
107 * @param[in] edge The edge to add
108 * @return Whether the edge was added (if not, it was deleted, too)
109 */
110 virtual bool addEdge(ROEdge* edge);
111
112
113 /* @brief Adds a district and connecting edges to the network
114 *
115 * If the district is already known (another one with the same id exists),
116 * an error is generated and given to msg-error-handler. The edges
117 * are deleted in this case and false is returned.
118 *
119 * @param[in] id The district to add
120 * @return Whether the district was added
121 */
122 bool addDistrict(const std::string id, ROEdge* source, ROEdge* sink);
123
124
125 /* @brief Adds a district and connecting edges to the network
126 *
127 * If the district is already known (another one with the same id exists),
128 * an error is generated and given to msg-error-handler. The edges
129 * are deleted in this case and false is returned.
130 *
131 * @param[in] id The district to add
132 * @return Whether the district was added
133 */
134 bool addDistrictEdge(const std::string tazID, const std::string edgeID, const bool isSource);
135
138
140 void setBidiEdges(const std::map<ROEdge*, std::string>& bidiMap);
141
146 const std::map<std::string, std::pair<std::vector<std::string>, std::vector<std::string> > >& getDistricts() const {
147 return myDistricts;
148 }
149
158 ROEdge* getEdge(const std::string& name) const {
159 return myEdges.get(name);
160 }
161
162
168 ROEdge* getEdgeForLaneID(const std::string& laneID) const;
169
175 ROLane* getLane(const std::string& laneID) const;
176
177 /* @brief Adds a read node to the network
178 *
179 * If the node is already known (another one with the same id exists),
180 * an error is generated and given to msg-error-handler. The node
181 * is deleted in this case
182 *
183 * @param[in] node The node to add
184 */
185 void addNode(RONode* node);
186
187
194 RONode* getNode(const std::string& id) const {
195 return myNodes.get(id);
196 }
197
198
199 /* @brief Adds a read stopping place (bus, train, container, parking) to the network
200 *
201 * If the place is already known (another one with the same id and category exists),
202 * an error is generated and given to msg-error-handler. The stop
203 * is deleted in this case
204 *
205 * @param[in] id The name of the stop to add
206 * @param[in] category The type of stop
207 * @param[in] stop The detailed stop description
208 */
209 void addStoppingPlace(const std::string& id, const SumoXMLTag category, SUMOVehicleParameter::Stop* stop);
210
217 const SUMOVehicleParameter::Stop* getStoppingPlace(const std::string& id, const SumoXMLTag category) const {
218 if (myStoppingPlaces.count(category) > 0) {
219 return myStoppingPlaces.find(category)->second.get(id);
220 }
221 return 0;
222 }
223
225 const std::string getStoppingPlaceName(const std::string& id) const;
226
228 const std::string getStoppingPlaceElement(const std::string& id) const;
230
231
232
234
235
242 bool checkVType(const std::string& id);
243
244
254 virtual bool addVehicleType(SUMOVTypeParameter* type);
255
256
270 bool addVTypeDistribution(const std::string& id, RandomDistributor<SUMOVTypeParameter*>* vehTypeDistribution);
271
272
282 const auto it = myVTypeDistDict.find(id);
283 return it != myVTypeDistDict.end() ? it ->second : nullptr;
284 }
285
286
296 SUMOVTypeParameter* getVehicleTypeSecure(const std::string& id);
297
298
299 /* @brief Adds a route definition to the network
300 *
301 * If the route definition is already known (another one with
302 * the same id exists), false is returned, but the route definition
303 * is not deleted.
304 *
305 * @param[in] def The route definition to add
306 * @return Whether the route definition could be added
307 * @todo Rename myRoutes to myRouteDefinitions
308 */
309 bool addRouteDef(RORouteDef* def);
310
311
319 RORouteDef* getRouteDef(const std::string& name) const {
320 return myRoutes.get(name);
321 }
322
323
324 /* @brief Adds a vehicle to the network
325 *
326 * If the vehicle is already known (another one with the same id
327 * exists), false is returned, but the vehicle is not deleted.
328 *
329 * Otherwise, the number of loaded routes ("myReadRouteNo") is increased.
330 *
331 * @param[in] id The id of the vehicle to add
332 * @param[in] veh The vehicle to add
333 * @return Whether the vehicle could be added
334 */
335 virtual bool addVehicle(const std::string& id, ROVehicle* veh);
336
338 bool knowsVehicle(const std::string& id) const;
339
341 SUMOTime getDeparture(const std::string& vehID) const;
342
343 /* @brief Adds a flow of vehicles to the network
344 *
345 * If the flow is already known (another one with the same id
346 * exists), false is returned, but the vehicle parameter are not deleted.
347 *
348 * Otherwise, the number of loaded routes ("myReadRouteNo") is increased.
349 *
350 * @param[in] flow The parameter of the flow to add
351 * @return Whether the flow could be added
352 */
353 bool addFlow(SUMOVehicleParameter* flow, const bool randomize);
354
355
356 /* @brief Adds a person to the network
357 *
358 * @param[in] person The person to add
359 */
360 bool addPerson(ROPerson* person);
361
362
363 /* @brief Adds a container to the network
364 *
365 * @param[in] depart The departure time of the container
366 * @param[in] desc The xml description of the container
367 */
368 void addContainer(const SUMOTime depart, const std::string desc);
369 // @}
370
371
373
374
387 const RORouterProvider& provider, SUMOTime time);
388
389
391 bool furtherStored();
393
394
401 void openOutput(const OptionsCont& options);
402
403
410 void writeIntermodal(const OptionsCont& options, ROIntermodalRouter& router) const;
411
412
414 void cleanup();
415
416
418 int getEdgeNumber() const;
419
421 int getInternalEdgeNumber() const;
422
424 return myEdges;
425 }
426
427 static void adaptIntermodalRouter(ROIntermodalRouter& router);
428
429 bool hasPermissions() const;
430
431 void setPermissionsFound();
432
434 bool hasBidiEdges() const {
435 return myHasBidiEdges;
436 }
437
439 bool hasLoadedEffort() const;
440
441 OutputDevice* getRouteOutput(const bool alternative = false) {
442 if (alternative) {
444 }
445 return myRoutesOutput;
446 }
447
448#ifdef HAVE_FOX
449 MFXWorkerThread::Pool& getThreadPool() {
450 return myThreadPool;
451 }
452
453 class WorkerThread : public MFXWorkerThread, public RORouterProvider {
454 public:
455 WorkerThread(MFXWorkerThread::Pool& pool,
456 const RORouterProvider& original)
457 : MFXWorkerThread(pool), RORouterProvider(original) {}
458 virtual ~WorkerThread() {
459 stop();
460 }
461 };
462
463 class BulkmodeTask : public MFXWorkerThread::Task {
464 public:
465 BulkmodeTask(const bool value) : myValue(value) {}
466 void run(MFXWorkerThread* context) {
467 static_cast<WorkerThread*>(context)->setBulkMode(myValue);
468 }
469 private:
470 const bool myValue;
471 private:
473 BulkmodeTask& operator=(const BulkmodeTask&);
474 };
475#endif
476
477
478private:
479 void checkFlows(SUMOTime time, MsgHandler* errorHandler);
480
481 void createBulkRouteRequests(const RORouterProvider& provider, const SUMOTime time, const bool removeLoops);
482
483private:
486
488 std::map<std::string, SUMOTime> myVehIDs;
489
491 std::set<std::string> myPersonIDs;
492
495
498
500 std::map<SumoXMLTag, NamedObjectCont<SUMOVehicleParameter::Stop*> > myStoppingPlaces;
501
504
506 typedef std::map< std::string, RandomDistributor<SUMOVTypeParameter*>* > VTypeDistDictType;
509
512
515
518
521
524
527
530
533
536
538 typedef std::multimap<const SUMOTime, const std::string> ContainerMap;
540
542 std::vector<const RORoutable*> myPTVehicles;
543
545 std::map<std::string, std::vector<SUMOTime> > myDepartures;
546
548 std::map<std::string, std::pair<std::vector<std::string>, std::vector<std::string> > > myDistricts;
549
552
555
558
561
564
567
570
572 std::map<std::string, std::map<SUMOVehicleClass, double> > myRestrictions;
573
576
579
581 const bool myKeepVTypeDist;
582
584 const bool myDoPTRouting;
585
588
589#ifdef HAVE_FOX
590private:
591 class RoutingTask : public MFXWorkerThread::Task {
592 public:
593 RoutingTask(RORoutable* v, const bool removeLoops, MsgHandler* errorHandler)
594 : myRoutable(v), myRemoveLoops(removeLoops), myErrorHandler(errorHandler) {}
595 void run(MFXWorkerThread* context);
596 private:
597 RORoutable* const myRoutable;
598 const bool myRemoveLoops;
599 MsgHandler* const myErrorHandler;
600 private:
602 RoutingTask& operator=(const RoutingTask&);
603 };
604
605
606private:
608 MFXWorkerThread::Pool myThreadPool;
609#endif
610
611private:
613 RONet(const RONet& src);
614
616 RONet& operator=(const RONet& src);
617
618};
long long int SUMOTime
Definition GUI.h:36
MapMatcher< ROEdge, ROLane, RONode > ROMapMatcher
Definition RONet.h:52
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.
Provides utility functions for matching locations to edges (during route parsing)
Definition MapMatcher.h:45
A map of named object pointers.
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.
Interface for building instances of router-edges.
A basic edge for routing applications.
Definition ROEdge.h:72
A single lane the router may use.
Definition ROLane.h:48
The router's network representation.
Definition RONet.h:63
void createBulkRouteRequests(const RORouterProvider &provider, const SUMOTime time, const bool removeLoops)
Definition RONet.cpp:626
SUMOVTypeParameter * getVehicleTypeSecure(const std::string &id)
Retrieves the named vehicle type.
Definition RONet.cpp:364
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:575
bool myDefaultPedTypeMayBeDeleted
Whether the default pedestrian type was already used or can still be replaced.
Definition RONet.h:514
bool hasBidiEdges() const
return whether the network contains bidirectional rail edges
Definition RONet.h:434
void setPermissionsFound()
Definition RONet.cpp:871
bool myDefaultRailTypeMayBeDeleted
Whether the default rail type was already used or can still be replaced.
Definition RONet.h:523
std::map< const SUMOTime, std::vector< RORoutable * > > RoutablesMap
Definition RONet.h:66
bool myDefaultVTypeMayBeDeleted
Whether the default vehicle type was already used or can still be replaced.
Definition RONet.h:511
void checkFlows(SUMOTime time, MsgHandler *errorHandler)
Definition RONet.cpp:540
RONode * getNode(const std::string &id) const
Retrieves an node from the network.
Definition RONet.h:194
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:150
std::map< std::string, RandomDistributor< SUMOVTypeParameter * > * > VTypeDistDictType
Vehicle type distribution dictionary type.
Definition RONet.h:506
const RandomDistributor< SUMOVTypeParameter * > * getVTypeDistribution(const std::string &id)
Retrieves the named vehicle type distribution.
Definition RONet.h:281
ContainerMap myContainers
Definition RONet.h:539
std::set< std::string > myPersonIDs
Known person ids.
Definition RONet.h:491
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:548
bool addRouteDef(RORouteDef *def)
Definition RONet.cpp:286
int myReadRouteNo
The number of read routes.
Definition RONet.h:560
void addStoppingPlace(const std::string &id, const SumoXMLTag category, SUMOVehicleParameter::Stop *stop)
Definition RONet.cpp:277
bool knowsVehicle(const std::string &id) const
returns whether a vehicle with the given id was already loaded
Definition RONet.cpp:488
void cleanup()
closes the file output for computed routes and deletes associated threads if necessary
Definition RONet.cpp:340
bool myHaveActiveFlows
whether any flows are still active
Definition RONet.h:535
RONet(const RONet &src)
Invalidated copy constructor.
std::map< std::string, SUMOTime > myVehIDs
Known vehicle ids and their departure.
Definition RONet.h:488
void openOutput(const OptionsCont &options)
Opens the output for computed routes.
Definition RONet.cpp:292
NamedObjectCont< SUMOVehicleParameter * > myFlows
Known flows.
Definition RONet.h:532
OutputDevice * myRouteAlternativesOutput
The file to write the computed route alternatives into.
Definition RONet.h:554
bool myDefaultBikeTypeMayBeDeleted
Whether the default bicycle type was already used or can still be replaced.
Definition RONet.h:517
RoutablesMap myRoutables
Known routables.
Definition RONet.h:529
int getInternalEdgeNumber() const
Returns the number of internal edges the network contains.
Definition RONet.cpp:801
virtual bool addVehicle(const std::string &id, ROVehicle *veh)
Definition RONet.cpp:466
SUMOTime getDeparture(const std::string &vehID) const
returns departure time for the given vehicle id
Definition RONet.cpp:493
OutputDevice * getRouteOutput(const bool alternative=false)
Definition RONet.h:441
bool myHasBidiEdges
whether the network contains bidirectional railway edges
Definition RONet.h:587
bool addDistrictEdge(const std::string tazID, const std::string edgeID, const bool isSource)
Definition RONet.cpp:197
MsgHandler * myErrorHandler
handler for ignorable error messages
Definition RONet.h:578
void writeIntermodal(const OptionsCont &options, ROIntermodalRouter &router) const
Writes the intermodal network and weights if requested.
Definition RONet.cpp:321
RONet()
Constructor.
Definition RONet.cpp:64
NamedObjectCont< RONode * > myNodes
Known nodes.
Definition RONet.h:494
const std::string getStoppingPlaceElement(const std::string &id) const
return the element name for the given stopping place id
Definition RONet.cpp:898
const SUMOVehicleParameter::Stop * getStoppingPlace(const std::string &id, const SumoXMLTag category) const
Retrieves a stopping place from the network.
Definition RONet.h:217
void addContainer(const SUMOTime depart, const std::string desc)
Definition RONet.cpp:534
static void adaptIntermodalRouter(ROIntermodalRouter &router)
Definition RONet.cpp:820
ROEdge * getEdge(const std::string &name) const
Retrieves an edge from the network.
Definition RONet.h:158
void addRestriction(const std::string &id, const SUMOVehicleClass svc, const double speed)
Adds a restriction for an edge type.
Definition RONet.cpp:144
NamedObjectCont< RORouteDef * > myRoutes
Known routes.
Definition RONet.h:526
bool furtherStored()
Returns the information whether further vehicles, persons or containers are stored.
Definition RONet.cpp:789
bool checkVType(const std::string &id)
Checks whether the vehicle type (distribution) may be added.
Definition RONet.cpp:396
OutputDevice * myRoutesOutput
The file to write the computed routes into.
Definition RONet.h:551
bool addPerson(ROPerson *person)
Definition RONet.cpp:522
int myWrittenRouteNo
The number of written routes.
Definition RONet.h:566
static RONet * myInstance
Unique instance of RONet.
Definition RONet.h:485
RORouteDef * getRouteDef(const std::string &name) const
Returns the named route definition.
Definition RONet.h:319
SUMOTime saveAndRemoveRoutesUntil(OptionsCont &options, const RORouterProvider &provider, SUMOTime time)
Computes routes described by their definitions and saves them.
Definition RONet.cpp:676
virtual bool addEdge(ROEdge *edge)
Definition RONet.cpp:160
bool myDefaultTaxiTypeMayBeDeleted
Whether the default taxi type was already used or can still be replaced.
Definition RONet.h:520
std::map< std::string, std::map< SUMOVehicleClass, double > > myRestrictions
The vehicle class specific speed restrictions.
Definition RONet.h:572
std::map< SumoXMLTag, NamedObjectCont< SUMOVehicleParameter::Stop * > > myStoppingPlaces
Known bus / train / container stops and parking areas.
Definition RONet.h:500
virtual bool addVehicleType(SUMOVTypeParameter *type)
Adds a read vehicle type definition to the network.
Definition RONet.cpp:442
bool myHavePermissions
Whether the network contains edges which not all vehicles may pass.
Definition RONet.h:569
bool hasPermissions() const
Definition RONet.cpp:865
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:255
ROLane * getLane(const std::string &laneID) const
Retrieves a lane rom the network given its id.
Definition RONet.cpp:813
std::multimap< const SUMOTime, const std::string > ContainerMap
Known containers.
Definition RONet.h:538
int myDiscardedRouteNo
The number of discarded routes.
Definition RONet.h:563
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:146
VTypeDistDictType myVTypeDistDict
A distribution of vehicle types (probability->vehicle type)
Definition RONet.h:508
std::vector< const RORoutable * > myPTVehicles
vehicles to keep for public transport routing
Definition RONet.h:542
NamedObjectCont< ROEdge * > myEdges
Known edges.
Definition RONet.h:497
void addNode(RONode *node)
Definition RONet.cpp:268
bool addVTypeDistribution(const std::string &id, RandomDistributor< SUMOVTypeParameter * > *vehTypeDistribution)
Adds a vehicle type distribution.
Definition RONet.cpp:455
void addJunctionTaz(ROAbstractEdgeBuilder &eb)
add a taz for every junction unless a taz with the same id already exists
Definition RONet.cpp:219
OutputDevice * myTypesOutput
The file to write the vehicle types into.
Definition RONet.h:557
const bool myDoPTRouting
whether to calculate routes for public transport
Definition RONet.h:584
const bool myKeepVTypeDist
whether to keep the vtype distribution in output
Definition RONet.h:581
virtual ~RONet()
Destructor.
Definition RONet.cpp:113
const std::string getStoppingPlaceName(const std::string &id) const
return the name for the given stopping place id
Definition RONet.cpp:886
std::map< std::string, std::vector< SUMOTime > > myDepartures
Departure times for randomized flows.
Definition RONet.h:545
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:795
const NamedObjectCont< ROEdge * > & getEdgeMap() const
Definition RONet.h:423
ROEdge * getEdgeForLaneID(const std::string &laneID) const
Retrieves an edge from the network when the lane id is given.
Definition RONet.cpp:807
bool addFlow(SUMOVehicleParameter *flow, const bool randomize)
Definition RONet.cpp:504
bool hasLoadedEffort() const
whether efforts were loaded from file
Definition RONet.cpp:876
NamedObjectCont< SUMOVTypeParameter * > myVehicleTypes
Known vehicle types.
Definition RONet.h:503
bool addDistrict(const std::string id, ROEdge *source, ROEdge *sink)
Definition RONet.cpp:174
Base class for nodes used by the router.
Definition RONode.h:46
A person as used by router.
Definition ROPerson.h:50
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
Represents a generic random distribution.
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