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              : // 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              : /****************************************************************************/
      14              : /// @file    PedestrianEdge.h
      15              : /// @author  Jakob Erdmann
      16              : /// @author  Michael Behrisch
      17              : /// @author  Robert Hilbrich
      18              : /// @date    Mon, 03 March 2014
      19              : ///
      20              : // The pedestrian accessible edges for the Intermodal Router
      21              : /****************************************************************************/
      22              : #pragma once
      23              : #include <config.h>
      24              : 
      25              : #define TL_RED_PENALTY 20
      26              : 
      27              : //#define IntermodalRouter_DEBUG_EFFORTS
      28              : 
      29              : 
      30              : // ===========================================================================
      31              : // class definitions
      32              : // ===========================================================================
      33              : /// @brief the pedestrian edge type that is given to the internal router (SUMOAbstractRouter)
      34              : template<class E, class L, class N, class V>
      35              : class PedestrianEdge : public IntermodalEdge<E, L, N, V> {
      36              : public:
      37      1108273 :     PedestrianEdge(int numericalID, const E* edge, const L* lane, bool forward, const double pos = -1.) :
      38              :         IntermodalEdge<E, L, N, V>(edge->getID() + (edge->isWalkingArea() ? "" : (forward ? "_fwd" : "_bwd")) + toString(pos), numericalID, edge, "!ped"),
      39      1108273 :         myLane(lane),
      40      1108273 :         myForward(forward),
      41      1061833 :         myStartPos(pos >= 0 ? pos : (forward ? 0. : edge->getLength())),
      42      2731949 :         myIsOpposite(false) {
      43      1108273 :         if (!forward && (
      44              :                     edge->getFunction() == SumoXMLEdgeFunc::NORMAL
      45       289046 :                     || edge->getFunction() == SumoXMLEdgeFunc::INTERNAL)) {
      46       210266 :             const L* sidewalk = getSidewalk<E, L>(edge);
      47       497263 :             if (sidewalk != nullptr && sidewalk->getPermissions() != SVC_PEDESTRIAN) {
      48              :                 // some non-pedestrian traffic is allowed
      49       392438 :                 myIsOpposite = true;
      50              :             }
      51              :         }
      52      1108273 :     }
      53              : 
      54      3977324 :     bool includeInRoute(bool allEdges) const {
      55      3977324 :         return allEdges || (!this->getEdge()->isCrossing() && !this->getEdge()->isWalkingArea() && !this->getEdge()->isInternal());
      56              :     }
      57              : 
      58     20530228 :     bool prohibits(const IntermodalTrip<E, N, V>* const trip) const {
      59     20530228 :         if (trip->node == 0) {
      60              :             // network only includes IntermodalEdges
      61              :             return false;
      62              :         } else {
      63              :             // limit routing to the surroundings of the specified node
      64              :             return (this->getEdge()->getFromJunction() != trip->node
      65     12089682 :                     && this->getEdge()->getToJunction() != trip->node);
      66              :         }
      67              :     }
      68              : 
      69     18533768 :     double getPartialLength(const IntermodalTrip<E, N, V>* const trip) const {
      70              :         double length = this->getLength();
      71     18533768 :         if (this->getEdge() == trip->from && !myForward && trip->departPos < myStartPos) {
      72       246709 :             length = trip->departPos - (myStartPos - this->getLength());
      73              :         }
      74     18533768 :         if (this->getEdge() == trip->to && myForward && trip->arrivalPos < myStartPos + this->getLength()) {
      75      1886412 :             length = trip->arrivalPos - myStartPos;
      76              :         }
      77     18533768 :         if (this->getEdge() == trip->from && myForward && trip->departPos > myStartPos) {
      78       254543 :             length -= (trip->departPos - myStartPos);
      79              :         }
      80     18533768 :         if (this->getEdge() == trip->to && !myForward && trip->arrivalPos > myStartPos - this->getLength()) {
      81       733755 :             length -= (trip->arrivalPos - (myStartPos - this->getLength()));
      82              :         }
      83              :         // ensure that 'normal' edges always have a higher weight than connector edges
      84              :         length = MAX2(length, NUMERICAL_EPS);
      85     18533768 :         return length;
      86              :     }
      87              : 
      88     17281646 :     double getTravelTime(const IntermodalTrip<E, N, V>* const trip, double time) const {
      89     17281646 :         const double length = getPartialLength(trip);
      90              :         double tlsDelay = 0;
      91              :         // @note pedestrian traffic lights should never have LINKSTATE_TL_REDYELLOW
      92     16032776 :         if (this->getEdge()->isCrossing() && myLane->getIncomingLinkState() == LINKSTATE_TL_RED) {
      93              :             // red traffic lights occurring later in the route may be green by the time we arrive
      94      3884634 :             tlsDelay += MAX2(double(0), TL_RED_PENALTY - (time - STEPS2TIME(trip->departTime)));
      95              :         }
      96     17281646 :         if (this->getEdge()->isCrossing()) {
      97      3695386 :             tlsDelay += this->getEdge()->getTimePenalty();
      98              :         }
      99              : #ifdef IntermodalRouter_DEBUG_EFFORTS
     100              :         std::cout << " effort for " << trip->getID() << " at " << time << " edge=" << this->getID() << " effort=" << length / trip->speed + tlsDelay << " l=" << length << " fullLength=" << this->getLength() << " s=" << trip->speed << " tlsDelay=" << tlsDelay << "\n";
     101              : #endif
     102     17281646 :         return length / (trip->speed * (myIsOpposite ? gWeightsWalkOppositeFactor : 1)) + tlsDelay;
     103              :     }
     104              : 
     105       184900 :     double getStartPos() const {
     106       184900 :         return myStartPos;
     107              :     }
     108              : 
     109       498641 :     double getEndPos() const {
     110       498641 :         return myForward ? myStartPos + this->getLength() : myStartPos - this->getLength();
     111              :     }
     112              : 
     113              : private:
     114              :     /// @brief  the original edge
     115              :     const L* myLane;
     116              : 
     117              :     /// @brief the direction of this edge
     118              :     const bool myForward;
     119              : 
     120              :     /// @brief the starting position for split edges
     121              :     const double myStartPos;
     122              : 
     123              :     /// @brief whether this edge goes against the flow of traffic
     124              :     bool myIsOpposite;
     125              : 
     126              : };