Line data    Source code

       1              : /****************************************************************************/
       2              : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3              : // Copyright (C) 2004-2025 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    ROJTREdge.cpp
      15              : /// @author  Daniel Krajzewicz
      16              : /// @author  Jakob Erdmann
      17              : /// @author  Michael Behrisch
      18              : /// @author  Yun-Pang Floetteroed
      19              : /// @date    Tue, 20 Jan 2004
      20              : ///
      21              : // An edge the jtr-router may route through
      22              : /****************************************************************************/
      23              : #include <config.h>
      24              : 
      25              : #include <algorithm>
      26              : #include <cassert>
      27              : #include <utils/common/MsgHandler.h>
      28              : #include <utils/common/RandHelper.h>
      29              : #include "ROJTREdge.h"
      30              : #include <utils/distribution/RandomDistributor.h>
      31              : 
      32              : 
      33              : // ===========================================================================
      34              : // method definitions
      35              : // ===========================================================================
      36         4786 : ROJTREdge::ROJTREdge(const std::string& id, RONode* from, RONode* to, int index, const int priority, const std::string& type, const std::string& routingType) :
      37              :     ROEdge(id, from, to, index, priority, type, routingType),
      38         4786 :     mySourceFlows(0)
      39         4786 : {}
      40              : 
      41              : 
      42         9572 : ROJTREdge::~ROJTREdge() {
      43        12376 :     for (FollowerUsageCont::iterator i = myFollowingDefs.begin(); i != myFollowingDefs.end(); ++i) {
      44        15180 :         delete (*i).second;
      45              :     }
      46        14358 : }
      47              : 
      48              : 
      49              : void
      50         8135 : ROJTREdge::addSuccessor(ROEdge* s, ROEdge* via, std::string dir) {
      51         8135 :     ROEdge::addSuccessor(s, via, dir);
      52         8135 :     ROJTREdge* js = static_cast<ROJTREdge*>(s);
      53         8135 :     if (myFollowingDefs.find(js) == myFollowingDefs.end()) {
      54         7590 :         myFollowingDefs[js] = new ValueTimeLine<double>();
      55              :     }
      56         8135 : }
      57              : 
      58              : 
      59              : void
      60         1323 : ROJTREdge::addFollowerProbability(ROJTREdge* follower, double begTime,
      61              :                                   double endTime, double probability) {
      62              :     FollowerUsageCont::iterator i = myFollowingDefs.find(follower);
      63         1323 :     if (i == myFollowingDefs.end()) {
      64            0 :         WRITE_ERRORF(TL("The edges '%' and '%' are not connected."), getID(), follower->getID());
      65              :         return;
      66              :     }
      67         1323 :     (*i).second->add(begTime, endTime, probability);
      68              : }
      69              : 
      70              : 
      71              : ROJTREdge*
      72       328491 : ROJTREdge::chooseNext(const ROVehicle* const veh, double time, const std::set<const ROEdge*>& avoid) const {
      73              :     // if no usable follower exist, return 0
      74              :     //  their probabilities are not yet regarded
      75       328491 :     if (myFollowingEdges.size() == 0 || (veh != nullptr && allFollowersProhibit(veh))) {
      76          564 :         return nullptr;
      77              :     }
      78              :     // gather information about the probabilities at this time
      79              :     RandomDistributor<ROJTREdge*> dist;
      80              :     // use the loaded definitions, first
      81      1200403 :     for (FollowerUsageCont::const_iterator i = myFollowingDefs.begin(); i != myFollowingDefs.end(); ++i) {
      82       872476 :         if (avoid.count(i->first) == 0) {
      83      1727956 :             if ((veh == nullptr || !(*i).first->prohibits(veh)) && (*i).second->describesTime(time)) {
      84        28684 :                 dist.add((*i).first, (*i).second->getValue(time));
      85              :             }
      86              :         }
      87              :     }
      88              :     // if no loaded definitions are valid for this time, try to use the defaults
      89       327927 :     if (dist.getOverallProb() == 0) {
      90      1151951 :         for (int i = 0; i < (int)myParsedTurnings.size(); ++i) {
      91       838604 :             if (avoid.count(myFollowingEdges[i]) == 0) {
      92      1664858 :                 if (veh == nullptr || !myFollowingEdges[i]->prohibits(veh)) {
      93       832527 :                     dist.add(static_cast<ROJTREdge*>(myFollowingEdges[i]), myParsedTurnings[i]);
      94              :                 }
      95              :             }
      96              :         }
      97              :     }
      98              :     // if still no valid follower exists, return null
      99       327927 :     if (dist.getOverallProb() == 0) {
     100              :         return nullptr;
     101              :     }
     102              :     // return one of the possible followers
     103       327097 :     return dist.get();
     104              : }
     105              : 
     106              : 
     107              : void
     108         4381 : ROJTREdge::setTurnDefaults(const std::vector<double>& defs) {
     109              :     // I hope, we'll find a less ridiculous solution for this
     110         4381 :     std::vector<double> tmp(defs.size()*myFollowingEdges.size(), 0);
     111              :     // store in less common multiple
     112        18190 :     for (int i = 0; i < (int)defs.size(); ++i) {
     113        38096 :         for (int j = 0; j < (int)myFollowingEdges.size(); ++j) {
     114        24287 :             tmp[i * myFollowingEdges.size() + j] = defs[i] / 100. / (double)myFollowingEdges.size();
     115              :         }
     116              :     }
     117              :     // parse from less common multiple
     118        11860 :     for (int i = 0; i < (int)myFollowingEdges.size(); ++i) {
     119              :         double value = 0;
     120        31766 :         for (int j = 0; j < (int)defs.size(); ++j) {
     121        24287 :             value += tmp[i * defs.size() + j];
     122              :         }
     123         7479 :         myParsedTurnings.push_back((double) value);
     124              :     }
     125         4381 : }
     126              : 
     127              : 
     128              : /****************************************************************************/