Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2001-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    AGActivity.cpp
      17             : /// @author  Piotr Woznica
      18             : /// @author  Daniel Krajzewicz
      19             : /// @author  Walter Bamberger
      20             : /// @date    July 2010
      21             : ///
      22             : // Parent object for all activities. Derived classes generate trips for each
      23             : // household.
      24             : /****************************************************************************/
      25             : #include <config.h>
      26             : 
      27             : #include <utils/common/RandHelper.h>
      28             : #include <activitygen/city/AGHousehold.h>
      29             : #include <activitygen/city/AGTime.h>
      30             : #include "AGActivity.h"
      31             : 
      32             : 
      33             : // ===========================================================================
      34             : // method definitions
      35             : // ===========================================================================
      36             : bool
      37           0 : AGActivity::isGenerated() {
      38           0 :     return genDone;
      39             : }
      40             : 
      41             : 
      42             : bool
      43           0 : AGActivity::generateTrips() {
      44           0 :     return true;
      45             : }
      46             : 
      47             : int
      48        4272 : AGActivity::possibleTranspMean(AGPosition destination) {
      49             :     int FOOT = 1;
      50             :     int BUS = 2;
      51             :     int CAR = 4;
      52             : 
      53             :     int transp = 0;
      54             : 
      55        4272 :     if (destination.distanceTo(myHousehold->getPosition()) <= myStatData->maxFootDistance) {
      56             :         transp = FOOT;
      57         282 :         if (myHousehold->getCarNbr() != 0) {
      58             :             transp += CAR;
      59             :         }
      60         282 :         if (destination.minDistanceTo(myStatData->busStations) <= myStatData->maxFootDistance
      61         555 :                 && myHousehold->getPosition().minDistanceTo(myStatData->busStations) <= myStatData->maxFootDistance) {
      62         270 :             transp += BUS;
      63             :         }
      64        3990 :     } else if (myHousehold->getCarNbr() == 0) {
      65         945 :         double d1 = destination.distanceTo(myHousehold->getPosition());
      66         945 :         double d2 = destination.minDistanceTo(myStatData->busStations) + myHousehold->getPosition().minDistanceTo(myStatData->busStations);
      67             : 
      68         945 :         if (d1 > d2) {
      69             :             transp = BUS;
      70             :         } else {
      71             :             transp = FOOT;
      72             :         }
      73        3045 :     } else if (myHousehold->getCarNbr() != 0) { //all other cases
      74        3045 :         if (destination.minDistanceTo(myStatData->busStations) > myStatData->maxFootDistance
      75        5781 :                 || myHousehold->getPosition().minDistanceTo(myStatData->busStations) > myStatData->maxFootDistance) {
      76             :             transp = CAR;
      77             :         } else {
      78             :             transp = CAR + BUS;
      79             :         }
      80             :     }
      81        4272 :     return transp;
      82             : }
      83             : 
      84             : int
      85         570 : AGActivity::availableTranspMeans(AGPosition from, AGPosition to) {
      86             :     int FOOT = 1;
      87             :     int BUS = 2;
      88             : 
      89             :     int available = 0;
      90             : 
      91         570 :     if (from.distanceTo(to) <= myStatData->maxFootDistance) {
      92             :         available += FOOT;
      93             :     }
      94         570 :     if (from.minDistanceTo(myStatData->busStations) <= myStatData->maxFootDistance
      95         570 :             && to.minDistanceTo(myStatData->busStations) <= myStatData->maxFootDistance) {
      96         481 :         available += BUS;
      97             :     }
      98         570 :     return available;
      99             : }
     100             : 
     101             : 
     102             : int
     103        1052 : AGActivity::timeToDrive(AGPosition from, AGPosition to) {
     104        1052 :     double dist = from.distanceTo(to);
     105        1052 :     return (int)(timePerKm * dist / 1000.0);
     106             : }
     107             : 
     108             : 
     109             : int
     110         726 : AGActivity::depHour(AGPosition from, AGPosition to, int arrival) {
     111             :     // ?? departure.addDays(1); // in case of negative time: arrival < timeToDrive
     112             :     //departure.setDay(0); // days are set to 0 because we want the time in the current day
     113         726 :     return (arrival - timeToDrive(from, to));
     114             : }
     115             : 
     116             : 
     117             : int
     118         326 : AGActivity::arrHour(AGPosition from, AGPosition to, int departure) {
     119         326 :     return (departure + timeToDrive(from, to));
     120             : }
     121             : 
     122             : 
     123             : int
     124         652 : AGActivity::randomTimeBetween(int begin, int end) {
     125         652 :     if (0 > begin || begin > end) {
     126             :         return -1;
     127             :     }
     128         652 :     if (begin == end) {
     129             :         return begin;
     130             :     }
     131         652 :     int tAlea = RandHelper::rand(end - begin);
     132         652 :     return (begin + tAlea);
     133             : }
     134             : 
     135             : 
     136             : std::list<AGTrip>&
     137        3011 : AGActivity::getPartialActivityTrips() {
     138        3011 :     return myPartialActivityTrips;
     139             : }
     140             : 
     141             : 
     142             : /****************************************************************************/