Eclipse SUMO - Simulation of Urban MObility
ODMatrix.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2006-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 /****************************************************************************/
20 // An O/D (origin/destination) matrix
21 /****************************************************************************/
22 #pragma once
23 #include <config.h>
24 
25 #include <iostream>
26 #include <sstream>
27 #include <fstream>
28 #include <vector>
29 #include <cstdlib>
30 #include <ctime>
31 #include <algorithm>
32 #include <set>
33 #include <string>
34 #include <utils/common/SUMOTime.h>
35 #include "ODCell.h"
36 #include "ODDistrictCont.h"
39 #include <utils/common/SUMOTime.h>
41 
42 // ===========================================================================
43 // class declarations
44 // ===========================================================================
45 class OptionsCont;
46 class OutputDevice;
47 class SUMOSAXHandler;
48 
49 
50 // ===========================================================================
51 // class definitions
52 // ===========================================================================
69 
70 public:
75  ODMatrix(const ODDistrictCont& dc);
76 
77 
79  ~ODMatrix();
80 
81 
103  bool add(double vehicleNumber, const std::pair<SUMOTime, SUMOTime>& beginEnd,
104  const std::string& origin, const std::string& destination,
105  const std::string& vehicleType,
106  const bool originIsEdge = false, const bool destinationIsEdge = false);
107 
119  bool add(const std::string& id, const SUMOTime depart,
120  const std::string& fromTaz, const std::string& toTaz,
121  const std::string& vehicleType,
122  const bool originIsEdge = false, const bool destinationIsEdge = false);
123 
131  void writeDefaultAttrs(OutputDevice& dev, const bool noVtype,
132  const ODCell* const cell);
133 
161  void write(SUMOTime begin, const SUMOTime end,
162  OutputDevice& dev, const bool uniform,
163  const bool differSourceSink, const bool noVtype,
164  const std::string& prefix, const bool stepLog,
165  bool pedestrians, bool persontrips,
166  const std::string& modes);
167 
168 
180  void writeFlows(const SUMOTime begin, const SUMOTime end,
181  OutputDevice& dev, const bool noVtype,
182  const std::string& prefix,
183  bool asProbability = false, bool pedestrians = false, bool persontrips = false,
184  const std::string& modes = "");
185 
186 
193  double getNumLoaded() const;
194 
195 
202  double getNumWritten() const;
203 
204 
211  double getNumDiscarded() const;
212 
213 
217  void applyCurve(const Distribution_Points& ps);
218 
219 
223  void readO(LineReader& lr, double scale,
224  std::string vehType, bool matrixHasVehType);
225 
229  void readV(LineReader& lr, double scale,
230  std::string vehType, bool matrixHasVehType);
231 
235  void loadMatrix(OptionsCont& oc);
236 
240  void loadRoutes(OptionsCont& oc, SUMOSAXHandler& handler);
241 
245  Distribution_Points parseTimeLine(const std::vector<std::string>& def, bool timelineDayInHours);
246 
247  const std::vector<ODCell*>& getCells() {
248  return myContainer;
249  }
250 
251  void sortByBeginTime();
252 
253  SUMOTime getBegin() const {
254  return myBegin;
255  }
256 
257  SUMOTime getEnd() const {
258  return myEnd;
259  }
260 
261  void addTazRelWeight(const std::string intervalID, const std::string& from, const std::string& to,
262  double val, double beg, double end);
263 
264 protected:
269  struct ODVehicle {
271  std::string id;
277  std::string from;
279  std::string to;
280 
281  };
282 
283 
309  double computeDeparts(ODCell* cell,
310  int& vehName, std::vector<ODVehicle>& into,
311  const bool uniform, const bool differSourceSink,
312  const std::string& prefix);
313 
314 
330  void applyCurve(const Distribution_Points& ps, ODCell* cell,
331  std::vector<ODCell*>& newCells);
332 
333 
334 private:
338  std::string getNextNonCommentLine(LineReader& lr);
339 
343  SUMOTime parseSingleTime(const std::string& time);
344 
348  std::pair<SUMOTime, SUMOTime> readTime(LineReader& lr);
349 
353  double readFactor(LineReader& lr, double scale);
354 
355 
356 private:
358  std::vector<ODCell*> myContainer;
359 
361  std::map<const std::pair<const std::string, const std::string>, std::vector<ODCell*> > myShortCut;
362 
365 
367  std::set<std::string> myMissingDistricts;
368 
370  double myNumLoaded;
371 
373  double myNumWritten;
374 
377 
380 
382  std::string myVType;
383 
389  public:
392 
393 
404  int operator()(ODCell* p1, ODCell* p2) const {
405  if (p1->begin == p2->begin) {
406  if (p1->origin == p2->origin) {
407  return p1->destination < p2->destination;
408  }
409  return p1->origin < p2->origin;
410  }
411  return p1->begin < p2->begin;
412  }
413 
414  };
415 
416 
425  public:
428 
429 
438  bool operator()(const ODVehicle& p1, const ODVehicle& p2) const {
439  if (p1.depart == p2.depart) {
440  return p1.id > p2.id;
441  }
442  return p1.depart > p2.depart;
443  }
444 
445  };
446 
447 private:
449  ODMatrix(const ODMatrix& s);
450 
452  ODMatrix& operator=(const ODMatrix& s) = delete;
453 
454 };
long long int SUMOTime
Definition: SUMOTime.h:32
Retrieves a file linewise and reports the lines to a handler.
Definition: LineReader.h:48
A container for districts.
Used for sorting the cells by the begin time they describe.
Definition: ODMatrix.h:388
int operator()(ODCell *p1, ODCell *p2) const
Comparing operator.
Definition: ODMatrix.h:404
Used for sorting vehicles by their departure (latest first)
Definition: ODMatrix.h:424
bool operator()(const ODVehicle &p1, const ODVehicle &p2) const
Comparing operator.
Definition: ODMatrix.h:438
An O/D (origin/destination) matrix.
Definition: ODMatrix.h:68
SUMOTime myEnd
Definition: ODMatrix.h:379
double getNumLoaded() const
Returns the number of loaded vehicles.
Definition: ODMatrix.cpp:586
void readV(LineReader &lr, double scale, std::string vehType, bool matrixHasVehType)
read a VISUM-matrix with the V Format
Definition: ODMatrix.cpp:472
bool add(double vehicleNumber, const std::pair< SUMOTime, SUMOTime > &beginEnd, const std::string &origin, const std::string &destination, const std::string &vehicleType, const bool originIsEdge=false, const bool destinationIsEdge=false)
Builds a single cell from the given values, verifying them.
Definition: ODMatrix.cpp:67
void sortByBeginTime()
Definition: ODMatrix.cpp:743
double readFactor(LineReader &lr, double scale)
Definition: ODMatrix.cpp:460
ODMatrix(const ODDistrictCont &dc)
Constructor.
Definition: ODMatrix.cpp:51
double computeDeparts(ODCell *cell, int &vehName, std::vector< ODVehicle > &into, const bool uniform, const bool differSourceSink, const std::string &prefix)
Computes the vehicle departs stored in the given cell and saves them in "into".
Definition: ODMatrix.cpp:155
const std::vector< ODCell * > & getCells()
Definition: ODMatrix.h:247
void addTazRelWeight(const std::string intervalID, const std::string &from, const std::string &to, double val, double beg, double end)
Definition: ODMatrix.cpp:694
SUMOTime myBegin
parsed time bounds
Definition: ODMatrix.h:379
~ODMatrix()
Destructor.
Definition: ODMatrix.cpp:55
SUMOTime parseSingleTime(const std::string &time)
Definition: ODMatrix.cpp:430
void writeFlows(const SUMOTime begin, const SUMOTime end, OutputDevice &dev, const bool noVtype, const std::string &prefix, bool asProbability=false, bool pedestrians=false, bool persontrips=false, const std::string &modes="")
Writes the flows stored in the matrix.
Definition: ODMatrix.cpp:329
void applyCurve(const Distribution_Points &ps)
Splits the stored cells dividing them on the given time line.
Definition: ODMatrix.cpp:620
SUMOTime getEnd() const
Definition: ODMatrix.h:257
std::map< const std::pair< const std::string, const std::string >, std::vector< ODCell * > > myShortCut
The loaded cells indexed by origin and destination.
Definition: ODMatrix.h:361
std::pair< SUMOTime, SUMOTime > readTime(LineReader &lr)
Definition: ODMatrix.cpp:441
void readO(LineReader &lr, double scale, std::string vehType, bool matrixHasVehType)
read a VISUM-matrix with the O Format
Definition: ODMatrix.cpp:541
std::set< std::string > myMissingDistricts
The missing districts already warned about.
Definition: ODMatrix.h:367
void write(SUMOTime begin, const SUMOTime end, OutputDevice &dev, const bool uniform, const bool differSourceSink, const bool noVtype, const std::string &prefix, const bool stepLog, bool pedestrians, bool persontrips, const std::string &modes)
Writes the vehicles stored in the matrix assigning the sources and sinks.
Definition: ODMatrix.cpp:223
const ODDistrictCont & myDistricts
The districts to retrieve sources/sinks from.
Definition: ODMatrix.h:364
Distribution_Points parseTimeLine(const std::vector< std::string > &def, bool timelineDayInHours)
split the given timeline
Definition: ODMatrix.cpp:718
void writeDefaultAttrs(OutputDevice &dev, const bool noVtype, const ODCell *const cell)
Helper function for flow and trip output writing the depart and arrival attributes.
Definition: ODMatrix.cpp:194
double myNumLoaded
Number of loaded vehicles.
Definition: ODMatrix.h:370
double myNumWritten
Number of written vehicles.
Definition: ODMatrix.h:373
SUMOTime getBegin() const
Definition: ODMatrix.h:253
void loadMatrix(OptionsCont &oc)
read a matrix in one of several formats
Definition: ODMatrix.cpp:633
void loadRoutes(OptionsCont &oc, SUMOSAXHandler &handler)
read SUMO routes
Definition: ODMatrix.cpp:701
double getNumWritten() const
Returns the number of written vehicles.
Definition: ODMatrix.cpp:592
std::vector< ODCell * > myContainer
The loaded cells.
Definition: ODMatrix.h:358
double myNumDiscarded
Number of discarded vehicles.
Definition: ODMatrix.h:376
ODMatrix & operator=(const ODMatrix &s)=delete
invalid assignment operator
double getNumDiscarded() const
Returns the number of discarded vehicles.
Definition: ODMatrix.cpp:598
std::string myVType
user-defined vType
Definition: ODMatrix.h:382
ODMatrix(const ODMatrix &s)
invalid copy constructor
std::string getNextNonCommentLine(LineReader &lr)
Definition: ODMatrix.cpp:418
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 a class which obtains read weights for named edges.
SAX-handler base for SUMO-files.
A single O/D-matrix cell.
Definition: ODCell.h:48
std::string destination
Name of the destination district.
Definition: ODCell.h:62
std::string origin
Name of the origin district.
Definition: ODCell.h:59
SUMOTime begin
The begin time this cell describes.
Definition: ODCell.h:53
An internal representation of a single vehicle.
Definition: ODMatrix.h:269
SUMOTime depart
The departure time of the vehicle.
Definition: ODMatrix.h:273
std::string from
The edge the vehicles shall start at.
Definition: ODMatrix.h:277
ODCell * cell
The cell of the ODMatrix which generated the vehicle.
Definition: ODMatrix.h:275
std::string to
The edge the vehicles shall end at.
Definition: ODMatrix.h:279
std::string id
The id of the vehicle.
Definition: ODMatrix.h:271