Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
ROLoader.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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/****************************************************************************/
22// Loader for networks and route imports
23/****************************************************************************/
24#include <config.h>
25
26#include <iostream>
27#include <string>
28#include <iomanip>
35#include <utils/xml/XMLSubSys.h>
39#include "RONet.h"
40#include "RONetHandler.h"
41#include "ROLoader.h"
42#include "ROLane.h"
43#include "ROEdge.h"
44#include "RORouteHandler.h"
45
46
47// ===========================================================================
48// method definitions
49// ===========================================================================
50// ---------------------------------------------------------------------------
51// ROLoader::EdgeFloatTimeLineRetriever_EdgeTravelTime - methods
52// ---------------------------------------------------------------------------
53void
55 double val, double beg, double end) const {
56 ROEdge* e = myNet.getEdge(id);
57 if (e != nullptr) {
58 e->addTravelTime(val, beg, end);
59 } else {
60 if (id[0] != ':') {
61 if (OptionsCont::getOptions().getBool("ignore-errors")) {
62 WRITE_WARNINGF(TL("Trying to set a weight for the unknown edge '%'."), id);
63 } else {
64 WRITE_ERRORF(TL("Trying to set a weight for the unknown edge '%'."), id);
65 }
66 }
67 }
68}
69
70
71// ---------------------------------------------------------------------------
72// ROLoader::EdgeFloatTimeLineRetriever_EdgeWeight - methods
73// ---------------------------------------------------------------------------
74void
76 double val, double beg, double end) const {
77 ROEdge* e = myNet.getEdge(id);
78 if (e != nullptr) {
79 e->addEffort(val, beg, end);
80 } else {
81 if (id[0] != ':') {
82 if (OptionsCont::getOptions().getBool("ignore-errors")) {
83 WRITE_WARNINGF(TL("Trying to set a weight for the unknown edge '%'."), id);
84 } else {
85 WRITE_ERRORF(TL("Trying to set a weight for the unknown edge '%'."), id);
86 }
87 }
88 }
89}
90
91
92// ---------------------------------------------------------------------------
93// ROLoader - methods
94// ---------------------------------------------------------------------------
95ROLoader::ROLoader(OptionsCont& oc, const bool emptyDestinationsAllowed, const bool logSteps) :
96 myOptions(oc),
97 myEmptyDestinationsAllowed(emptyDestinationsAllowed),
98 myLogSteps(logSteps),
99 myLoaders(oc.exists("unsorted-input") && oc.getBool("unsorted-input") ? 0 : DELTA_T) {
100}
101
102
105
106
107void
109 std::string file = myOptions.getString("net-file");
110 if (file == "") {
111 throw ProcessError(TL("Missing definition of network to load!"));
112 }
113 if (!FileHelpers::isReadable(file)) {
114 throw ProcessError(TLF("The network file '%' is not accessible.", file));
115 }
116 PROGRESS_BEGIN_MESSAGE(TL("Loading net"));
117 RONetHandler handler(toFill, eb, !myOptions.exists("no-internal-links") || myOptions.getBool("no-internal-links"),
118 myOptions.exists("weights.minor-penalty") ? myOptions.getFloat("weights.minor-penalty") : 0);
119 handler.setFileName(file);
120 if (!XMLSubSys::runParser(handler, file, true)) {
122 throw ProcessError();
123 } else {
125 }
126 if (myOptions.exists("restriction-params") && myOptions.isSet("restriction-params")) {
127 const std::vector<std::string> paramKeys = myOptions.getStringVector("restriction-params");
128 for (auto& edgeIt : toFill.getEdgeMap()) {
129 edgeIt.second->cacheParamRestrictions(paramKeys);
130 }
131 }
132 if (!deprecatedVehicleClassesSeen.empty()) {
133 WRITE_WARNINGF(TL("Deprecated vehicle classes '%' in input network."), toString(deprecatedVehicleClassesSeen));
135 }
136 if (myOptions.isSet("additional-files", false)) { // dfrouter does not register this option
137 std::vector<std::string> files = myOptions.getStringVector("additional-files");
138 for (std::vector<std::string>::const_iterator fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
139 if (!FileHelpers::isReadable(*fileIt)) {
140 throw ProcessError(TLF("The additional file '%' is not accessible.", *fileIt));
141 }
142 PROGRESS_BEGIN_MESSAGE("Loading additional file '" + *fileIt + "' ");
143 handler.setFileName(*fileIt);
144 if (!XMLSubSys::runParser(handler, *fileIt)) {
146 throw ProcessError();
147 } else {
149 }
150 }
151 }
152 if (myOptions.exists("junction-taz") && myOptions.getBool("junction-taz")) {
153 // create a TAZ for every junction
154 toFill.addJunctionTaz(eb);
155 }
156 toFill.setBidiEdges(handler.getBidiMap());
157}
158
159
160void
162 // build loader
163 // load relevant elements from additional file
164 bool ok = openTypedRoutes("additional-files", net, true);
165 // load sumo routes, trips, and flows
166 ok &= openTypedRoutes("route-files", net);
167 // check
168 if (ok) {
170 if (!net.furtherStored()) {
171 if (MsgHandler::getErrorInstance()->wasInformed()) {
172 throw ProcessError();
173 } else {
174 const std::string error = "No route input specified or all routes were invalid.";
175 if (myOptions.getBool("ignore-errors")) {
176 WRITE_WARNING(error);
177 } else {
178 throw ProcessError(error);
179 }
180 }
181 }
182 // skip routes prior to the begin time
183 if (!myOptions.getBool("unsorted-input")) {
184 WRITE_MESSAGE("Skipped until: " + time2string(myLoaders.getFirstLoadTime()));
185 }
186 }
187}
188
189
190void
191ROLoader::processRoutes(const SUMOTime start, const SUMOTime end, const SUMOTime increment,
192 RONet& net, const RORouterProvider& provider) {
193 const SUMOTime absNo = end - start;
194 const bool endGiven = !OptionsCont::getOptions().isDefault("end");
195 // skip routes that begin before the simulation's begin
196 // loop till the end
197 const SUMOTime firstStep = myLoaders.getFirstLoadTime();
198 SUMOTime lastStep = firstStep;
199 SUMOTime time = MIN2(firstStep, end);
200 while (time <= end) {
201 writeStats(time, start, absNo, endGiven);
202 myLoaders.loadNext(time);
204 break;
205 }
206 lastStep = net.saveAndRemoveRoutesUntil(myOptions, provider, time);
207 if (time == end || (!net.furtherStored() && myLoaders.haveAllLoaded()) || MsgHandler::getErrorInstance()->wasInformed()) {
208 break;
209 }
210 if (time < end && time > end - increment) {
211 time = end;
212 } else {
213 time += increment;
214 }
215 }
216 if (myLogSteps) {
217 WRITE_MESSAGEF(TL("Routes found between time steps % and %."), time2string(firstStep), time2string(lastStep));
218 }
219}
220
221
222bool
223ROLoader::openTypedRoutes(const std::string& optionName,
224 RONet& net, const bool readAll) {
225 // check whether the current loader is wished
226 // and the file(s) can be used
227 if (!myOptions.isUsableFileList(optionName)) {
228 return !myOptions.isSet(optionName);
229 }
230 for (const std::string& fileIt : myOptions.getStringVector(optionName)) {
231 try {
232 RORouteHandler* handler = new RORouteHandler(net, fileIt, myOptions.getBool("repair"), myEmptyDestinationsAllowed, myOptions.getBool("ignore-errors"), !readAll);
233 if (readAll) {
234 if (!XMLSubSys::runParser(*handler, fileIt)) {
235 WRITE_ERRORF(TL("Loading of % failed."), fileIt);
236 return false;
237 }
238 delete handler;
239 } else {
240 myLoaders.add(new SUMORouteLoader(handler));
241 }
242 } catch (ProcessError& e) {
243 WRITE_ERRORF(TL("The loader for % from file '%' could not be initialised (%)."), optionName, fileIt, e.what());
244 return false;
245 }
246 }
247 return true;
248}
249
250
251bool
252ROLoader::loadWeights(RONet& net, const std::string& optionName,
253 const std::string& measure, const bool useLanes, const bool boundariesOverride) {
254 // check whether the file exists
255 if (!myOptions.isUsableFileList(optionName)) {
256 return false;
257 }
258 // build and prepare the weights handler
259 std::vector<SAXWeightsHandler::ToRetrieveDefinition*> retrieverDefs;
260 // travel time, first (always used)
262 retrieverDefs.push_back(new SAXWeightsHandler::ToRetrieveDefinition("traveltime", !useLanes, ttRetriever));
263 // the measure to use, then
265 if (measure != "traveltime") {
266 std::string umeasure = measure;
267 if (measure == "CO" || measure == "CO2" || measure == "HC" || measure == "PMx" || measure == "NOx" || measure == "fuel" || measure == "electricity") {
268 umeasure = measure + "_perVeh";
269 }
270 retrieverDefs.push_back(new SAXWeightsHandler::ToRetrieveDefinition(umeasure, !useLanes, eRetriever));
271 }
272 // set up handler
273 SAXWeightsHandler handler(retrieverDefs, "");
274 // go through files
275 std::vector<std::string> files = myOptions.getStringVector(optionName);
276 for (std::vector<std::string>::const_iterator fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
277 PROGRESS_BEGIN_MESSAGE("Loading precomputed net weights from '" + *fileIt + "'");
278 if (XMLSubSys::runParser(handler, *fileIt)) {
280 } else {
281 WRITE_MESSAGE(TL("failed."));
282 return false;
283 }
284 }
285 // build edge-internal time lines
286 for (const auto& i : net.getEdgeMap()) {
287 i.second->buildTimeLines(measure, boundariesOverride);
288 }
289 return true;
290}
291
292
293void
294ROLoader::writeStats(const SUMOTime time, const SUMOTime start, const SUMOTime absNo, bool endGiven) {
295 if (myLogSteps) {
296 if (endGiven) {
297 const double perc = (double)(time - start) / (double) absNo;
298 std::cout << "Reading up to time step: " + time2string(time) + " (" + time2string(time - start) + "/" + time2string(absNo) + " = " + toString(perc * 100) + "% done) \r";
299 } else {
300 std::cout << "Reading up to time step: " + time2string(time) + "\r";
301 }
302 }
303}
304
305
306/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:271
#define WRITE_MESSAGEF(...)
Definition MsgHandler.h:273
#define WRITE_ERRORF(...)
Definition MsgHandler.h:280
#define WRITE_MESSAGE(msg)
Definition MsgHandler.h:272
#define WRITE_WARNING(msg)
Definition MsgHandler.h:270
#define TL(string)
Definition MsgHandler.h:287
#define PROGRESS_DONE_MESSAGE()
Definition MsgHandler.h:275
#define TLF(string,...)
Definition MsgHandler.h:288
#define PROGRESS_FAILED_MESSAGE()
Definition MsgHandler.h:278
#define PROGRESS_BEGIN_MESSAGE(msg)
Definition MsgHandler.h:274
SUMOTime DELTA_T
Definition SUMOTime.cpp:38
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition SUMOTime.cpp:69
std::set< std::string > deprecatedVehicleClassesSeen
T MIN2(T a, T b)
Definition StdDefs.h:76
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:46
static bool isReadable(std::string path)
Checks whether the given file is readable.
void setFileName(const std::string &name)
Sets the current file name.
bool wasInformed() const
Returns the information whether any messages were added.
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
A storage for options typed value containers)
Definition OptionsCont.h:89
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
bool exists(const std::string &name) const
Returns the information whether the named option is known.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
static OptionsCont & getOptions()
Retrieves the options.
bool isUsableFileList(const std::string &name) const
Checks whether the named option is usable as a file list (with at least a single file)
Interface for building instances of router-edges.
A basic edge for routing applications.
Definition ROEdge.h:70
void addEffort(double value, double timeBegin, double timeEnd)
Adds a weight value.
Definition ROEdge.cpp:140
void addTravelTime(double value, double timeBegin, double timeEnd)
Adds a travel time value.
Definition ROEdge.cpp:147
Obtains edge travel times from a weights handler and stores them within the edges.
Definition ROLoader.h:142
RONet & myNet
The network edges shall be obtained from.
Definition ROLoader.h:163
void addEdgeWeight(const std::string &id, double val, double beg, double end) const
Adds a travel time for a given edge and time period.
Definition ROLoader.cpp:54
Obtains edge weights from a weights handler and stores them within the edges.
Definition ROLoader.h:111
void addEdgeWeight(const std::string &id, double val, double beg, double end) const
Adds an effort for a given edge and time period.
Definition ROLoader.cpp:75
bool loadWeights(RONet &net, const std::string &optionName, const std::string &measure, const bool useLanes, const bool boundariesOverride)
Loads the net weights.
Definition ROLoader.cpp:252
bool openTypedRoutes(const std::string &optionName, RONet &net, const bool readAll=false)
Opens route handler of the given type.
Definition ROLoader.cpp:223
SUMORouteLoaderControl myLoaders
List of route loaders.
Definition ROLoader.h:184
void processRoutes(const SUMOTime start, const SUMOTime end, const SUMOTime increment, RONet &net, const RORouterProvider &provider)
Loads routes from all previously build route loaders.
Definition ROLoader.cpp:191
virtual ~ROLoader()
Destructor.
Definition ROLoader.cpp:103
ROLoader(OptionsCont &oc, const bool emptyDestinationsAllowed, const bool logSteps)
Constructor.
Definition ROLoader.cpp:95
virtual void loadNet(RONet &toFill, ROAbstractEdgeBuilder &eb)
Loads the network.
Definition ROLoader.cpp:108
void writeStats(const SUMOTime time, const SUMOTime start, const SUMOTime absNo, bool endGiven)
Definition ROLoader.cpp:294
void openRoutes(RONet &net)
Builds and opens all route loaders.
Definition ROLoader.cpp:161
const bool myLogSteps
Information whether the routing steps should be logged.
Definition ROLoader.h:181
OptionsCont & myOptions
Options to use.
Definition ROLoader.h:175
const bool myEmptyDestinationsAllowed
Information whether empty destinations are allowed.
Definition ROLoader.h:178
The handler that parses a SUMO-network for its usage in a router.
The router's network representation.
Definition RONet.h:62
ROEdge * getEdge(const std::string &name) const
Retrieves an edge from the network.
Definition RONet.h:157
bool furtherStored()
Returns the information whether further vehicles, persons or containers are stored.
Definition RONet.cpp:787
SUMOTime saveAndRemoveRoutesUntil(OptionsCont &options, const RORouterProvider &provider, SUMOTime time)
Computes routes described by their definitions and saves them.
Definition RONet.cpp:676
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
void addJunctionTaz(ROAbstractEdgeBuilder &eb)
add a taz for every junction unless a taz with the same id already exists
Definition RONet.cpp:219
const NamedObjectCont< ROEdge * > & getEdgeMap() const
Definition RONet.h:409
Parser and container for routes during their loading.
Complete definition about what shall be retrieved and where to store it.
An XML-handler for network weights.
SUMOTime getFirstLoadTime() const
returns the timestamp of the first loaded vehicle or flow
bool haveAllLoaded() const
returns whether loading is completed
void loadNext(SUMOTime step)
loads the next routes up to and including the given time step
void add(SUMORouteLoader *loader)
add another loader
static bool runParser(GenericSAXHandler &handler, const std::string &file, const bool isNet=false, const bool isRoute=false, const bool isExternal=false, const bool catchExceptions=true)
Runs the given handler on the given file; returns if everything's ok.