Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2010-2024 German Aerospace Center (DLR) and others.
       4             : // activitygen module
       5             : // Copyright 2010 TUM (Technische Universitaet Muenchen, http://www.tum.de/)
       6             : // This program and the accompanying materials are made available under the
       7             : // terms of the Eclipse Public License 2.0 which is available at
       8             : // https://www.eclipse.org/legal/epl-2.0/
       9             : // This Source Code may also be made available under the following Secondary
      10             : // Licenses when the conditions for such availability set forth in the Eclipse
      11             : // Public License 2.0 are satisfied: GNU General Public License, version 2
      12             : // or later which is available at
      13             : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      14             : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      15             : /****************************************************************************/
      16             : /// @file    AGTrip.cpp
      17             : /// @author  Piotr Woznica
      18             : /// @author  Daniel Krajzewicz
      19             : /// @author  Walter Bamberger
      20             : /// @author  Jakob Erdmann
      21             : /// @author  Michael Behrisch
      22             : /// @date    July 2010
      23             : ///
      24             : // Class containing all information of a given trip (car, bus)
      25             : /****************************************************************************/
      26             : #include <config.h>
      27             : 
      28             : #include "AGTrip.h"
      29             : 
      30             : 
      31             : // ===========================================================================
      32             : // method definitions
      33             : // ===========================================================================
      34             : bool
      35       33797 : AGTrip::operator <(const AGTrip& trip) const {
      36       33797 :     if (getDay() < trip.getDay()) {
      37             :         return true;
      38             :     }
      39       33797 :     if (getDay() == trip.getDay())
      40       33797 :         if (getTime() < trip.getTime()) {
      41       14977 :             return true;
      42             :         }
      43             :     return false;
      44             : }
      45             : 
      46             : void
      47           0 : AGTrip::print() const {
      48             :     std::cout << "Trip: " << std::endl;
      49           0 :     std::cout << "\t-From= ";
      50           0 :     myFrom.print();
      51           0 :     std::cout << "\t-To= ";
      52           0 :     myTo.print();
      53           0 :     std::cout << "\t-At= " << myDepTime << " -Day= " << myDay << std::endl;
      54             :     std::cout << "\t-Vehicle= " << myVehicle << std::endl;
      55             :     std::cout << "\t-type= " << myType << std::endl;
      56           0 : }
      57             : 
      58             : void
      59        5980 : AGTrip::addLayOver(AGPosition by) {
      60        5980 :     myPassBy.push_back(by);
      61        5980 : }
      62             : 
      63             : void
      64          29 : AGTrip::addLayOver(AGTrip& trip) {
      65             :     std::list<AGPosition>::iterator it;
      66          29 :     for (it = trip.myPassBy.begin(); it != trip.myPassBy.end(); ++it) {
      67           0 :         myPassBy.push_back(*it);
      68             :     }
      69          29 :     myPassBy.push_back(trip.myTo);
      70          29 : }
      71             : 
      72             : void
      73        7665 : AGTrip::addLayOverWithoutDestination(AGTrip& trip) {
      74             :     std::list<AGPosition>::iterator it;
      75       16657 :     for (it = trip.myPassBy.begin(); it != trip.myPassBy.end(); ++it) {
      76        8992 :         myPassBy.push_back(*it);
      77             :     }
      78        7665 : }
      79             : 
      80             : const std::list<AGPosition>*
      81       14350 : AGTrip::getPassed() const {
      82       14350 :     return &myPassBy;
      83             : }
      84             : 
      85             : const std::string&
      86       19144 : AGTrip::getType() const {
      87       19144 :     return myType;
      88             : }
      89             : 
      90             : void
      91        9190 : AGTrip::setType(std::string type) {
      92        9190 :     myType = type;
      93        9190 : }
      94             : 
      95             : AGPosition
      96       23265 : AGTrip::getDep() const {
      97       23265 :     return myFrom;
      98             : }
      99             : 
     100             : AGPosition
     101       22860 : AGTrip::getArr() const {
     102       22860 :     return myTo;
     103             : }
     104             : 
     105             : int
     106      106577 : AGTrip::getTime() const {
     107      106577 :     return myDepTime;
     108             : }
     109             : 
     110             : int
     111        3702 : AGTrip::getTimeTrip(double secPerKm) const {
     112             :     double dist = 0;
     113             :     std::list<AGPosition> positions;
     114        3702 :     positions.push_back(myFrom);
     115             :     std::list<AGPosition>::const_iterator it;
     116        3841 :     for (it = myPassBy.begin(); it != myPassBy.end(); ++it) {
     117             :         positions.push_back(*it);
     118             :     }
     119        3702 :     positions.push_back(myTo);
     120             : 
     121             :     const AGPosition* temp = &positions.front();
     122        7543 :     for (it = positions.begin(), ++it; it != positions.end(); ++it) {
     123        3841 :         dist += temp->distanceTo(*it);
     124             :         temp = &*it;
     125             :     }
     126        7404 :     return (int)(secPerKm * (dist / 1000.0));
     127             : }
     128             : 
     129             : int
     130        3273 : AGTrip::getArrTime(double secPerKm) const {
     131        3273 :     return myDepTime + getTimeTrip(secPerKm);
     132             : }
     133             : 
     134             : int
     135          86 : AGTrip::getRideBackArrTime(double secPerKm) const {
     136          86 :     return getArrTime(secPerKm) + (int)(secPerKm * myTo.distanceTo(myFrom) / 1000.0);
     137             : }
     138             : 
     139             : void
     140        5045 : AGTrip::setDepTime(int time) {
     141        5045 :     myDepTime = time;
     142        5045 : }
     143             : 
     144             : int
     145         429 : AGTrip::estimateDepTime(int arrTime, double secPerKm) const {
     146         429 :     return arrTime - getTimeTrip(secPerKm);
     147             : }
     148             : 
     149             : const std::string&
     150       42744 : AGTrip::getVehicleName() const {
     151       42744 :     return myVehicle;
     152             : }
     153             : 
     154             : void
     155        7693 : AGTrip::setVehicleName(std::string name) {
     156        7693 :     myVehicle = name;
     157        7693 : }
     158             : 
     159             : void
     160          28 : AGTrip::setArr(AGPosition arrival) {
     161          28 :     myTo = AGPosition(arrival.getStreet(), arrival.getPosition());
     162          28 : }
     163             : 
     164             : void
     165           0 : AGTrip::setDep(AGPosition departure) {
     166           0 :     myFrom = AGPosition(departure.getStreet(), departure.getPosition());
     167           0 : }
     168             : 
     169             : bool
     170        9812 : AGTrip::isDaily() const {
     171        9812 :     return (myDay == 0);
     172             : }
     173             : 
     174             : int
     175      179938 : AGTrip::getDay() const {
     176      179938 :     return myDay;
     177             : }
     178             : 
     179             : void
     180        4616 : AGTrip::setDay(int d) {
     181        4616 :     myDay = d;
     182        4616 : }
     183             : 
     184             : 
     185             : /****************************************************************************/