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    AGWorkAndSchool.cpp
      17             : /// @author  Piotr Woznica
      18             : /// @author  Daniel Krajzewicz
      19             : /// @author  Michael Behrisch
      20             : /// @author  Walter Bamberger
      21             : /// @date    July 2010
      22             : ///
      23             : // Generates trips to work and to school
      24             : /****************************************************************************/
      25             : #include <config.h>
      26             : 
      27             : #include <list>
      28             : #include <utils/common/SUMOVehicleClass.h>
      29             : #include <activitygen/city/AGCar.h>
      30             : #include <activitygen/city/AGChild.h>
      31             : #include <activitygen/city/AGHousehold.h>
      32             : #include <activitygen/city/AGStreet.h>
      33             : #include <activitygen/city/AGWorkPosition.h>
      34             : #include "AGWorkAndSchool.h"
      35             : 
      36             : 
      37             : // ===========================================================================
      38             : // method definitions
      39             : // ===========================================================================
      40             : bool
      41        1506 : AGWorkAndSchool::generateTrips() {
      42             :     //buildDestinations();
      43             :     // generation of the waiting list for the accompaniment
      44        1506 :     buildChildrenAccompaniment();
      45             : 
      46        1506 :     buildWorkDestinations();
      47             : 
      48        1506 :     if (myHousehold->getCarNbr() < (int)personsDrivingCars.size()) {
      49             :         return false;    //to rebuild the household
      50             :     }
      51        1506 :     if (childrenNeedingCarAccompaniment.size() != 0 && myHousehold->getCarNbr() == 0) {
      52             :         return false;    //to rebuild the household
      53             :     }
      54        1506 :     if (adultNeedingCarAccompaniment.size() != 0 && myHousehold->getCarNbr() == 0) {
      55             :         return false;
      56             :     }
      57             : 
      58        1506 :     carAllocation();
      59             : 
      60        1506 :     if (personsDrivingCars.empty() && notNeedingDrivers.empty()) {
      61         969 :         genDone = true;
      62         969 :         return true; // no trip to generate
      63             :     }
      64             : 
      65         537 :     if (! carsToTrips()) {
      66             :         return false;
      67             :     }
      68             : 
      69         537 :     genDone = true;
      70         537 :     return true;
      71             : }
      72             : 
      73             : void
      74        1506 : AGWorkAndSchool::buildChildrenAccompaniment() {
      75             :     std::list<AGChild>::const_iterator itC;
      76        2076 :     for (itC = myHousehold->getChildren().begin(); itC != myHousehold->getChildren().end(); ++itC) {
      77         570 :         if (itC->haveASchool()) {
      78         570 :             if (this->availableTranspMeans(myHousehold->getPosition(), itC->getSchoolLocation()) == 0) {
      79             :                 //in this case the school is far from home and bus stations too
      80          74 :                 this->childrenNeedingCarAccompaniment.push_back(*itC);
      81             :             }
      82             :         }
      83             :     }
      84        1506 : }
      85             : 
      86             : void
      87        1506 : AGWorkAndSchool::buildWorkDestinations() {
      88             :     std::list<AGAdult>::const_iterator itA;
      89        3942 :     for (itA = myHousehold->getAdults().begin(); itA != myHousehold->getAdults().end(); ++itA) {
      90        2436 :         if (itA->isWorking()) {
      91        1622 :             if (this->possibleTranspMean(itA->getWorkPosition().getPosition()) % 2 == 0) {
      92             :                 //not too close, to not being able to go by foot
      93        1325 :                 if (this->possibleTranspMean(itA->getWorkPosition().getPosition()) > 4) {
      94             :                     //too far from home ==> Car or Bus AND Car and bus are possible
      95         736 :                     workingPeoplePossCar.push_back(*itA);
      96         589 :                 } else if (this->possibleTranspMean(itA->getWorkPosition().getPosition()) == 4) {
      97             :                     //only the car is possible (and there is one (use of possibleTranspMean))
      98         279 :                     if (myHousehold->getCarNbr() > (int)personsDrivingCars.size()) {
      99         245 :                         personsDrivingCars.push_back(*itA);
     100             :                     } else {
     101          34 :                         adultNeedingCarAccompaniment.push_back(*itA);
     102             :                     }
     103             :                 }
     104             :             }
     105             :         }
     106             :     }
     107             : 
     108             :     // sometimes, people still have choice: when vehicles are available and their car take a bus.
     109             :     std::list<AGAdult>::iterator it;
     110        2242 :     for (it = workingPeoplePossCar.begin(); it != workingPeoplePossCar.end(); ++it) {
     111         736 :         if (possibleTranspMean(it->getWorkPosition().getPosition()) == 6 && myHousehold->getCarNbr() > (int)personsDrivingCars.size()) {
     112             :             //car or bus (always because of workDestinations' construction) AND at least one car not used
     113         634 :             if (myHousehold->getAdults().front().decide(this->carPreference)) {
     114         332 :                 personsDrivingCars.push_back(*it);
     115             :             }
     116             :         }
     117             :     }
     118        1506 : }
     119             : 
     120             : void
     121        1506 : AGWorkAndSchool::carAllocation() {
     122             :     // only two adults are possibles: no car, 1 car, 2 cars and more
     123             :     // the only choice case: 1 car / 2 adults needing this car (otherwise no choice problems)
     124        1506 :     if (! personsDrivingCars.empty() && ! adultNeedingCarAccompaniment.empty()) {
     125             :         //in that case there is only one element in each list and only one car.
     126          34 :         if (adultNeedingCarAccompaniment.front().getWorkPosition().getOpening() >= personsDrivingCars.front().getWorkPosition().getOpening()) {
     127             :             //we will invert the driver and the accompanied
     128          25 :             personsDrivingCars.push_back(adultNeedingCarAccompaniment.front());
     129          25 :             adultNeedingCarAccompaniment.pop_front();
     130             :             adultNeedingCarAccompaniment.push_back(personsDrivingCars.front());
     131             :             personsDrivingCars.pop_front();
     132             :         }
     133             :     }
     134        1506 :     if (personsDrivingCars.empty() && ! childrenNeedingCarAccompaniment.empty()) {
     135             :         //at least one adult exists because no household contains less than one adult
     136          16 :         if ((int)workingPeoplePossCar.size() != myHousehold->getAdultNbr()) { //personsDrivingCars.size() + adultNeedingCarAccompaniment.size() is equal to 0
     137             :             std::list<AGAdult>::const_iterator itUA;
     138          18 :             for (itUA = myHousehold->getAdults().begin(); itUA != myHousehold->getAdults().end(); ++itUA) {
     139          18 :                 if (! itUA->isWorking()) {
     140          16 :                     notNeedingDrivers.push_back(*itUA);
     141             :                     break;
     142             :                 }
     143             :             }
     144             :         } else {
     145           0 :             personsDrivingCars.push_back(workingPeoplePossCar.front());
     146           0 :             workingPeoplePossCar.pop_front();
     147             :         }
     148             :     }
     149        1506 : }
     150             : 
     151             : bool
     152         537 : AGWorkAndSchool::carsToTrips() {
     153             :     // check if the starting edge allows cars
     154         537 :     if (!myHousehold->getPosition().getStreet().allows(SVC_PASSENGER)) {
     155             :         return false;
     156             :     }
     157             :     std::list<AGAdult>::const_iterator itDriA;
     158         537 :     std::list<AGCar>::const_iterator itCar = myHousehold->getCars().begin();
     159        1114 :     for (itDriA = personsDrivingCars.begin(); itDriA != personsDrivingCars.end(); ++itDriA) {
     160             :         //check if the number of cars is lower than the number of drivers
     161         577 :         if (itCar == myHousehold->getCars().end()) {
     162           0 :             return false;
     163             :         }
     164             :         // check if the destination edge allows cars
     165         577 :         if (!itDriA->getWorkPosition().getPosition().getStreet().allows(SVC_PASSENGER)) {
     166             :             return false;
     167             :         }
     168        1154 :         AGTrip trip(myHousehold->getPosition(), itDriA->getWorkPosition().getPosition(), *itCar, depHour(myHousehold->getPosition(), itDriA->getWorkPosition().getPosition(), itDriA->getWorkPosition().getOpening()));
     169             :         ++itCar;
     170         577 :         tempTrip.push_back(trip);
     171         577 :     }
     172             : 
     173             :     std::list<AGAdult>::iterator itAccA;
     174         571 :     for (itAccA = adultNeedingCarAccompaniment.begin(); itAccA != adultNeedingCarAccompaniment.end(); ++itAccA) {
     175          34 :         AGTrip trip(myHousehold->getPosition(), itAccA->getWorkPosition().getPosition(), depHour(myHousehold->getPosition(), itAccA->getWorkPosition().getPosition(), itAccA->getWorkPosition().getOpening()));
     176          34 :         tempAccTrip.push_back(trip);
     177          34 :     }
     178             : 
     179             :     std::list<AGChild>::iterator itAccC;
     180         611 :     for (itAccC = childrenNeedingCarAccompaniment.begin(); itAccC != childrenNeedingCarAccompaniment.end(); ++itAccC) {
     181          74 :         AGTrip trip(myHousehold->getPosition(), itAccC->getSchoolLocation(), depHour(myHousehold->getPosition(), itAccC->getSchoolLocation(), itAccC->getSchoolOpening()));
     182          74 :         tempAccTrip.push_back(trip);
     183          74 :     }
     184             : 
     185         537 :     checkAndBuildTripConsistancy();
     186         537 :     if (isThereUnusedCar() && ! checkDriversScheduleMatching()) {
     187           0 :         makePossibleDriversDrive();
     188             :     }
     189             : 
     190         537 :     generateListTrips();
     191             :     return true;
     192             : }
     193             : 
     194             : bool
     195         537 : AGWorkAndSchool::isThereUnusedCar() {
     196         537 :     return (myHousehold->getCarNbr() > static_cast<int>(notNeedingDrivers.size() + personsDrivingCars.size()));
     197             : }
     198             : 
     199             : bool
     200         537 : AGWorkAndSchool::checkAndBuildTripConsistancy() {
     201             :     bool finish = false;
     202             :     int diff1, diff2;
     203             :     int arrTime;
     204             :     std::list<AGTrip>::iterator it1, it2;
     205             : 
     206        1103 :     while (!finish) {
     207             :         finish = true;
     208         645 :         for (it1 = tempAccTrip.begin(); it1 != tempAccTrip.end(); ++it1) {
     209         216 :             for (it2 = tempAccTrip.begin(); it2 != tempAccTrip.end(); ++it2) {
     210         137 :                 if (it1 == it2) {
     211         108 :                     continue;
     212             :                 }
     213          29 :                 diff1 = it2->getTime() - it1->getRideBackArrTime(this->timePerKm);
     214          29 :                 diff2 = it1->getTime() - it2->getRideBackArrTime(this->timePerKm);
     215             : 
     216          29 :                 if (diff1 < 0 || diff2 < 0) {
     217          29 :                     if (diff2 < diff1) {
     218          12 :                         arrTime = it2->getArrTime(this->timePerKm);
     219          12 :                         it2->addLayOver(*it1);
     220          12 :                         it2->setDepTime(it2->estimateDepTime(arrTime, this->timePerKm));
     221          12 :                         tempAccTrip.erase(it1);
     222             :                     } else {
     223          17 :                         arrTime = it1->getArrTime(this->timePerKm);
     224          17 :                         it1->addLayOver(*it2);
     225          17 :                         it1->setDepTime(it1->estimateDepTime(arrTime, this->timePerKm));
     226          17 :                         tempAccTrip.erase(it2);
     227             :                     }
     228             :                     finish = false;
     229             :                     break;
     230             :                 }
     231             :             }
     232             :             if (!finish) {
     233             :                 break; // return to while
     234             :             }
     235             :         }
     236             :     }
     237         537 :     return finish;
     238             : }
     239             : 
     240             : bool
     241          99 : AGWorkAndSchool::checkDriversScheduleMatching() {
     242             :     bool check = false;
     243             :     std::list<AGTrip>::iterator itAccT;
     244             :     std::list<AGTrip>::iterator itDriT;
     245             :     std::list<AGAdult>::iterator itA;
     246         111 :     for (itAccT = tempAccTrip.begin(); itAccT != tempAccTrip.end(); ++itAccT) {
     247          14 :         for (itDriT = tempTrip.begin(); itDriT != tempTrip.end(); ++itDriT) {
     248           2 :             if (itAccT->getArrTime(this->timePerKm) < itDriT->getArrTime(this->timePerKm)) {
     249             :                 check = true;
     250             :             }
     251             :         }
     252          22 :         for (itA = notNeedingDrivers.begin(); itA != notNeedingDrivers.end(); ++itA) {
     253          10 :             if (!itA->isWorking()) {
     254             :                 check = true;
     255           0 :             } else if (itAccT->getRideBackArrTime(this->timePerKm) < itA->getWorkPosition().getOpening()) {
     256             :                 check = true;
     257             :             }
     258             :         }
     259          12 :         if (!check) { //at least one trip is not performed by the existing drivers because it is to late for them
     260             :             return false;
     261             :         }
     262             :         check = false;
     263             :     }
     264             :     return true;
     265             : }
     266             : 
     267             : void
     268         537 : AGWorkAndSchool::generateListTrips() {
     269             :     int arrTime;
     270             :     std::list<AGTrip>::iterator itAccT;
     271             :     std::list<AGTrip>::iterator itDriT;
     272             :     std::list<AGAdult>::iterator itA;
     273             :     bool alreadyDone;
     274             : 
     275             :     /**
     276             :      * 1 / 3 : Accompaniment
     277             :      */
     278         616 :     for (itAccT = tempAccTrip.begin(); itAccT != tempAccTrip.end(); ++itAccT) {
     279             :         alreadyDone = false;
     280         155 :         for (itDriT = tempTrip.begin(); itDriT != tempTrip.end(); ++itDriT) {
     281          76 :             if (!alreadyDone) {
     282          70 :                 if (itAccT->getArrTime(this->timePerKm) < itDriT->getArrTime(this->timePerKm) && !alreadyDone) {
     283             :                     //Add the accompaniment trip to the driver's trip OR new trip
     284          28 :                     if (itAccT->getRideBackArrTime(this->timePerKm) < itDriT->getTime()) {
     285             :                         //there is enough time to accompany people and go back home before going to work
     286          56 :                         itAccT->setVehicleName(itDriT->getVehicleName());
     287          28 :                         itAccT->addLayOver(itAccT->getArr());//final destination is the last accompaniment stop: not the destination of the course
     288          28 :                         itAccT->setArr(myHousehold->getPosition());//final destination of the whole trip: home
     289          28 :                         myPartialActivityTrips.push_back(*itAccT);
     290             :                         alreadyDone = true;
     291             :                     } else {
     292             :                         //the driver drives people to their working place or school and goes directly to work after that
     293           0 :                         arrTime = itDriT->getArrTime(this->timePerKm);
     294           0 :                         itDriT->addLayOver(*itAccT);
     295           0 :                         itDriT->setDepTime(itDriT->estimateDepTime(arrTime, this->timePerKm));
     296             :                         //tempAccTrip.erase(itAccT);
     297             :                         //--itAccT; //because of erasure
     298             :                         alreadyDone = true;
     299             :                     }
     300             :                 }
     301             :             }
     302             :         }
     303             : 
     304          95 :         for (itA = notNeedingDrivers.begin(); itA != notNeedingDrivers.end(); ++itA) {
     305          16 :             if (!itA->isWorking() && !alreadyDone) {
     306          16 :                 std::string nameC = getUnusedCar();
     307          16 :                 if (nameC.size() != 0) {
     308           0 :                     itAccT->setVehicleName(getUnusedCar());
     309           0 :                     itAccT->addLayOver(itAccT->getArr());
     310           0 :                     itAccT->setArr(myHousehold->getPosition());
     311           0 :                     myPartialActivityTrips.push_back(*itAccT);
     312             :                     alreadyDone = true;
     313             :                 }
     314           0 :             } else if (itAccT->getRideBackArrTime(this->timePerKm) < itA->getWorkPosition().getOpening() && !alreadyDone) {
     315           0 :                 std::string nameC = getUnusedCar();
     316           0 :                 if (nameC.size() != 0) {
     317           0 :                     itAccT->setVehicleName(getUnusedCar());
     318           0 :                     itAccT->addLayOver(itAccT->getArr());
     319           0 :                     itAccT->setArr(myHousehold->getPosition());
     320           0 :                     myPartialActivityTrips.push_back(*itAccT);
     321             :                     alreadyDone = true;
     322             :                 }
     323             :             }
     324             :         }
     325             :     }
     326             : 
     327             :     /**
     328             :      * 2/3 : drivers way
     329             :      */
     330        1114 :     for (itDriT = tempTrip.begin(); itDriT != tempTrip.end(); ++itDriT) {
     331         577 :         myPartialActivityTrips.push_back(*itDriT);
     332             :     }
     333             : 
     334             :     /**
     335             :      * 3/3: way return
     336             :      */
     337        1114 :     for (itA = personsDrivingCars.begin(); itA != personsDrivingCars.end(); ++itA) {
     338         577 :         for (itDriT = tempTrip.begin(); itDriT != tempTrip.end(); ++itDriT) {
     339         577 :             if (itA->getWorkPosition().getPosition() == itDriT->getArr()) {
     340        1154 :                 AGTrip trip(itA->getWorkPosition().getPosition(), myHousehold->getPosition(), itDriT->getVehicleName(), itA->getWorkPosition().getClosing());
     341         577 :                 myPartialActivityTrips.push_back(trip);
     342         577 :                 tempTrip.erase(itDriT);
     343             :                 break;
     344         577 :             }
     345             :         }
     346             :     }
     347         537 : }
     348             : 
     349             : std::string
     350          16 : AGWorkAndSchool::getUnusedCar() {
     351          16 :     std::string nameCar = "";
     352          16 :     std::string nameCarUsed = "";
     353             :     //only two cars can be used in the household, so: the first one or the last one is not used.
     354          16 :     if (!tempTrip.empty()) {
     355           0 :         nameCarUsed = tempTrip.front().getVehicleName();
     356          16 :     } else if (!myPartialActivityTrips.empty()) {
     357           0 :         nameCarUsed = myPartialActivityTrips.front().getVehicleName();
     358             :     }
     359             : 
     360          16 :     if (nameCarUsed.size() != 0) {
     361           0 :         if (myHousehold->getCars().front().getName() == nameCarUsed) {
     362           0 :             nameCar = myHousehold->getCars().back().getName();
     363             :         } else {
     364           0 :             nameCar = myHousehold->getCars().front().getName();
     365             :         }
     366             :     }
     367          16 :     return nameCar;
     368             : }
     369             : 
     370             : void
     371           0 : AGWorkAndSchool::makePossibleDriversDrive() {
     372             :     //give to a non working adult the ability to drive children or someone else.
     373           0 :     if ((int)(workingPeoplePossCar.size() + personsDrivingCars.size() + adultNeedingCarAccompaniment.size()) != myHousehold->getAdultNbr()) {
     374             :         std::list<AGAdult>::const_iterator itUA;
     375           0 :         for (itUA = myHousehold->getAdults().begin(); itUA != myHousehold->getAdults().end(); ++itUA) {
     376           0 :             if (! itUA->isWorking()) {
     377           0 :                 notNeedingDrivers.push_back(*itUA);
     378             :                 break;
     379             :             }
     380             :         }
     381             :     }
     382           0 : }
     383             : 
     384             : 
     385             : /****************************************************************************/