LCOV - code coverage report
Current view: top level - src/libsumo - Edge.cpp (source / functions) Coverage Total Hit
Test: lcov.info Lines: 96.1 % 228 219
Test Date: 2026-10-12 15:53:19 Functions: 96.4 % 55 53

            Line data    Source code
       1              : /****************************************************************************/
       2              : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3              : // Copyright (C) 2017-2026 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    Edge.cpp
      15              : /// @author  Gregor Laemmel
      16              : /// @date    15.09.2017
      17              : ///
      18              : // C++ TraCI client API implementation
      19              : /****************************************************************************/
      20              : #include <config.h>
      21              : 
      22              : #include <iterator>
      23              : #include <microsim/MSEdge.h>
      24              : #include <microsim/MSLane.h>
      25              : #include <microsim/MSEdgeWeightsStorage.h>
      26              : #include <microsim/transportables/MSTransportable.h>
      27              : #include <microsim/MSVehicle.h>
      28              : #include <microsim/MSInsertionControl.h>
      29              : #include <libsumo/Helper.h>
      30              : #include <libsumo/StorageHelper.h>
      31              : #include <libsumo/TraCIDefs.h>
      32              : #include <libsumo/TraCIConstants.h>
      33              : #include <libsumo/Lane.h>
      34              : #include <utils/emissions/HelpersHarmonoise.h>
      35              : #include "Edge.h"
      36              : 
      37              : 
      38              : namespace libsumo {
      39              : // ===========================================================================
      40              : // static member initializations
      41              : // ===========================================================================
      42              : SubscriptionResults Edge::mySubscriptionResults;
      43              : ContextSubscriptionResults Edge::myContextSubscriptionResults;
      44              : 
      45              : 
      46              : // ===========================================================================
      47              : // static member definitions
      48              : // ===========================================================================
      49              : std::vector<std::string>
      50          287 : Edge::getIDList() {
      51          287 :     MSNet::getInstance(); // just to check that we actually have a network
      52            0 :     std::vector<std::string> ids;
      53          285 :     MSEdge::insertIDs(ids);
      54          285 :     return ids;
      55            0 : }
      56              : 
      57              : 
      58              : int
      59           16 : Edge::getIDCount() {
      60           16 :     return (int)getIDList().size();
      61              : }
      62              : 
      63              : 
      64              : double
      65          114 : Edge::getAdaptedTraveltime(const std::string& edgeID, double time) {
      66          114 :     const MSEdge* e = getEdge(edgeID);
      67              :     double value;
      68          114 :     if (!MSNet::getInstance()->getWeightsStorage().retrieveExistingTravelTime(e, time, value)) {
      69              :         return -1.;
      70              :     }
      71           37 :     return value;
      72              : }
      73              : 
      74              : 
      75              : double
      76           54 : Edge::getEffort(const std::string& edgeID, double time) {
      77           54 :     const MSEdge* e = getEdge(edgeID);
      78              :     double value;
      79           54 :     if (!MSNet::getInstance()->getWeightsStorage().retrieveExistingEffort(e, time, value)) {
      80              :         return -1.;
      81              :     }
      82           27 :     return value;
      83              : }
      84              : 
      85              : 
      86              : double
      87          178 : Edge::getTraveltime(const std::string& edgeID) {
      88          178 :     return getEdge(edgeID)->getCurrentTravelTime();
      89              : }
      90              : 
      91              : 
      92              : MSEdge*
      93        40505 : Edge::getEdge(const std::string& edgeID) {
      94        40505 :     MSEdge* e = MSEdge::dictionary(edgeID);
      95        40505 :     if (e == nullptr) {
      96            8 :         throw TraCIException("Edge '" + edgeID + "' is not known");
      97              :     }
      98        40501 :     return e;
      99              : }
     100              : 
     101              : 
     102              : double
     103           14 : Edge::getWaitingTime(const std::string& edgeID) {
     104           14 :     return getEdge(edgeID)->getWaitingSeconds();
     105              : }
     106              : 
     107              : 
     108              : const std::vector<std::string>
     109        18395 : Edge::getLastStepPersonIDs(const std::string& edgeID) {
     110            0 :     std::vector<std::string> personIDs;
     111        18395 :     std::vector<MSTransportable*> persons = getEdge(edgeID)->getSortedPersons(MSNet::getInstance()->getCurrentTimeStep(), true);
     112        18395 :     personIDs.reserve(persons.size());
     113        19034 :     for (MSTransportable* p : persons) {
     114          639 :         personIDs.push_back(p->getID());
     115              :     }
     116        18395 :     return personIDs;
     117        18395 : }
     118              : 
     119              : 
     120              : const std::vector<std::string>
     121           64 : Edge::getLastStepVehicleIDs(const std::string& edgeID) {
     122            0 :     std::vector<std::string> vehIDs;
     123          369 :     for (const SUMOVehicle* veh : getEdge(edgeID)->getVehicles()) {
     124          305 :         vehIDs.push_back(veh->getID());
     125           62 :     }
     126           62 :     return vehIDs;
     127            2 : }
     128              : 
     129              : 
     130              : double
     131           17 : Edge::getCO2Emission(const std::string& edgeID) {
     132              :     double sum = 0;
     133           50 :     for (MSLane* lane : getEdge(edgeID)->getLanes()) {
     134           33 :         sum += lane->getEmissions<PollutantsInterface::CO2>();
     135              :     }
     136           17 :     return sum;
     137              : }
     138              : 
     139              : 
     140              : double
     141           17 : Edge::getCOEmission(const std::string& edgeID) {
     142              :     double sum = 0;
     143           50 :     for (MSLane* lane : getEdge(edgeID)->getLanes()) {
     144           33 :         sum += lane->getEmissions<PollutantsInterface::CO>();
     145              :     }
     146           17 :     return sum;
     147              : }
     148              : 
     149              : 
     150              : double
     151           17 : Edge::getHCEmission(const std::string& edgeID) {
     152              :     double sum = 0;
     153           50 :     for (MSLane* lane : getEdge(edgeID)->getLanes()) {
     154           33 :         sum += lane->getEmissions<PollutantsInterface::HC>();
     155              :     }
     156           17 :     return sum;
     157              : }
     158              : 
     159              : 
     160              : double
     161           17 : Edge::getPMxEmission(const std::string& edgeID) {
     162              :     double sum = 0;
     163           50 :     for (MSLane* lane : getEdge(edgeID)->getLanes()) {
     164           33 :         sum += lane->getEmissions<PollutantsInterface::PM_X>();
     165              :     }
     166           17 :     return sum;
     167              : }
     168              : 
     169              : 
     170              : double
     171           17 : Edge::getNOxEmission(const std::string& edgeID) {
     172              :     double sum = 0;
     173           50 :     for (MSLane* lane : getEdge(edgeID)->getLanes()) {
     174           33 :         sum += lane->getEmissions<PollutantsInterface::NO_X>();
     175              :     }
     176           17 :     return sum;
     177              : }
     178              : 
     179              : 
     180              : double
     181           17 : Edge::getFuelConsumption(const std::string& edgeID) {
     182              :     double sum = 0;
     183           50 :     for (MSLane* lane : getEdge(edgeID)->getLanes()) {
     184           33 :         sum += lane->getEmissions<PollutantsInterface::FUEL>();
     185              :     }
     186           17 :     return sum;
     187              : }
     188              : 
     189              : 
     190              : double
     191           17 : Edge::getNoiseEmission(const std::string& edgeID) {
     192              :     double sum = 0;
     193           50 :     for (MSLane* lane : getEdge(edgeID)->getLanes()) {
     194           33 :         sum += pow(10., (lane->getHarmonoise_NoiseEmissions() / 10.));
     195              :     }
     196           17 :     if (sum != 0) {
     197           17 :         return HelpersHarmonoise::sum(sum);
     198              :     }
     199              :     return sum;
     200              : }
     201              : 
     202              : 
     203              : double
     204           13 : Edge::getElectricityConsumption(const std::string& edgeID) {
     205              :     double sum = 0;
     206           42 :     for (MSLane* lane : getEdge(edgeID)->getLanes()) {
     207           29 :         sum += lane->getEmissions<PollutantsInterface::ELEC>();
     208              :     }
     209           13 :     return sum;
     210              : }
     211              : 
     212              : 
     213              : int
     214          399 : Edge::getLastStepVehicleNumber(const std::string& edgeID) {
     215          399 :     return getEdge(edgeID)->getVehicleNumber();
     216              : }
     217              : 
     218              : 
     219              : double
     220           67 : Edge::getLastStepMeanSpeed(const std::string& edgeID) {
     221           67 :     return getEdge(edgeID)->getMeanSpeed();
     222              : }
     223              : 
     224              : double
     225           18 : Edge::getMeanFriction(const std::string& edgeID) {
     226           18 :     return getEdge(edgeID)->getMeanFriction();
     227              : }
     228              : 
     229              : 
     230              : double
     231           33 : Edge::getMaxSpeed(const std::string& edgeID) {
     232           33 :     return getEdge(edgeID)->getSpeedLimit();
     233              : }
     234              : 
     235              : 
     236              : double
     237           22 : Edge::getLastStepOccupancy(const std::string& edgeID) {
     238           22 :     return getEdge(edgeID)->getOccupancy();
     239              : }
     240              : 
     241              : 
     242              : int
     243           17 : Edge::getLastStepHaltingNumber(const std::string& edgeID) {
     244              :     int result = 0;
     245           32 :     for (const SUMOVehicle* veh : getEdge(edgeID)->getVehicles()) {
     246           15 :         if (veh->getSpeed() < SUMO_const_haltingSpeed) {
     247            3 :             result++;
     248              :         }
     249           17 :     }
     250           17 :     return result;
     251              : }
     252              : 
     253              : 
     254              : double
     255           17 : Edge::getLastStepLength(const std::string& edgeID) {
     256              :     double lengthSum = 0;
     257              :     int numVehicles = 0;
     258           32 :     for (const SUMOVehicle* veh : getEdge(edgeID)->getVehicles()) {
     259           15 :         numVehicles++;
     260           15 :         lengthSum += dynamic_cast<const MSBaseVehicle*>(veh)->getVehicleType().getLength();
     261           17 :     }
     262           17 :     if (numVehicles == 0) {
     263              :         return 0;
     264              :     }
     265           15 :     return lengthSum / numVehicles;
     266              : }
     267              : 
     268              : 
     269              : int
     270           14 : Edge::getLaneNumber(const std::string& edgeID) {
     271           14 :     return (int)getEdge(edgeID)->getLanes().size();
     272              : }
     273              : 
     274              : 
     275              : std::string
     276           14 : Edge::getStreetName(const std::string& edgeID) {
     277           14 :     return getEdge(edgeID)->getStreetName();
     278              : }
     279              : 
     280              : 
     281              : const std::vector<std::string>
     282           58 : Edge::getPendingVehicles(const std::string& edgeID) {
     283           58 :     getEdge(edgeID); // validate edgeID
     284            0 :     std::vector<std::string> vehIDs;
     285           70 :     for (const SUMOVehicle* veh : MSNet::getInstance()->getInsertionControl().getPendingVehicles()) {
     286           12 :         if (veh->getEdge()->getID() == edgeID) {
     287           12 :             vehIDs.push_back(veh->getID());
     288              :         }
     289              :     }
     290           58 :     return vehIDs;
     291            0 : }
     292              : 
     293              : 
     294              : double
     295           18 : Edge::getAngle(const std::string& edgeID, double relativePosition) {
     296           18 :     const std::vector<MSLane*>& lanes = getEdge(edgeID)->getLanes();
     297           18 :     return lanes.empty() ? libsumo::INVALID_DOUBLE_VALUE : Lane::getAngle(lanes.front()->getID(), relativePosition);
     298              : }
     299              : 
     300              : std::string
     301           13 : Edge::getFromJunction(const std::string& edgeID) {
     302           13 :     return getEdge(edgeID)->getFromJunction()->getID();
     303              : }
     304              : 
     305              : std::string
     306           13 : Edge::getToJunction(const std::string& edgeID) {
     307           13 :     return getEdge(edgeID)->getToJunction()->getID();
     308              : }
     309              : 
     310              : std::string
     311           98 : Edge::getBidiEdge(const std::string& edgeID) {
     312           98 :     const MSEdge* bidi = getEdge(edgeID)->getBidiEdge();
     313           98 :     return bidi == nullptr ? "" : bidi->getID();
     314              : }
     315              : 
     316              : std::string
     317          135 : Edge::getParameter(const std::string& edgeID, const std::string& param) {
     318          270 :     return getEdge(edgeID)->getParameter(param, "");
     319              : }
     320              : 
     321              : 
     322          102 : LIBSUMO_GET_PARAMETER_WITH_KEY_IMPLEMENTATION(Edge)
     323              : 
     324              : 
     325              : void
     326            2 : Edge::setAllowed(const std::string& edgeID, std::string allowedClasses) {
     327            2 :     setAllowedSVCPermissions(edgeID, parseVehicleClasses(allowedClasses));
     328            2 : }
     329              : 
     330              : 
     331              : void
     332            8 : Edge::setAllowed(const std::string& edgeID, std::vector<std::string> allowedClasses) {
     333            8 :     setAllowedSVCPermissions(edgeID, parseVehicleClasses(allowedClasses));
     334            8 : }
     335              : 
     336              : 
     337              : void
     338            0 : Edge::setDisallowed(const std::string& edgeID, std::string disallowedClasses) {
     339            0 :     setAllowedSVCPermissions(edgeID, invertPermissions(parseVehicleClasses(disallowedClasses)));
     340            0 : }
     341              : 
     342              : 
     343              : void
     344            5 : Edge::setDisallowed(const std::string& edgeID, std::vector<std::string> disallowedClasses) {
     345            5 :     setAllowedSVCPermissions(edgeID, invertPermissions(parseVehicleClasses(disallowedClasses)));
     346            5 : }
     347              : 
     348              : 
     349              : void
     350           15 : Edge::setAllowedSVCPermissions(const std::string& edgeID, long long int permissions) {
     351           15 :     MSEdge* e = getEdge(edgeID);
     352           30 :     for (MSLane* lane : e->getLanes()) {
     353           15 :         lane->setPermissions(permissions, MSLane::CHANGE_PERMISSIONS_PERMANENT);
     354              :     }
     355           15 :     e->rebuildAllowedLanes(false, true);
     356           15 : }
     357              : 
     358              : 
     359              : void
     360           85 : Edge::adaptTraveltime(const std::string& edgeID, double time, double beginSeconds, double endSeconds) {
     361           85 :     MSNet::getInstance()->getWeightsStorage().addTravelTime(getEdge(edgeID), beginSeconds, endSeconds, time);
     362           84 : }
     363              : 
     364              : 
     365              : void
     366           18 : Edge::setEffort(const std::string& edgeID, double effort, double beginSeconds, double endSeconds) {
     367           18 :     MSNet::getInstance()->getWeightsStorage().addEffort(getEdge(edgeID), beginSeconds, endSeconds, effort);
     368           17 : }
     369              : 
     370              : 
     371              : void
     372           21 : Edge::setMaxSpeed(const std::string& edgeID, double speed) {
     373           21 :     getEdge(edgeID)->setMaxSpeed(speed);
     374           21 : }
     375              : 
     376              : void
     377            5 : Edge::setFriction(const std::string& edgeID, double friction) {
     378           10 :     for (MSLane* lane : getEdge(edgeID)->getLanes()) {
     379            5 :         lane->setFrictionCoefficient(friction);
     380              :     }
     381            5 : }
     382              : 
     383              : void
     384           99 : Edge::setParameter(const std::string& edgeID, const std::string& name, const std::string& value) {
     385           99 :     getEdge(edgeID)->setParameter(name, value);
     386           99 : }
     387              : 
     388              : 
     389         8362 : LIBSUMO_SUBSCRIPTION_IMPLEMENTATION(Edge, EDGE)
     390              : 
     391              : 
     392              : void
     393        20375 : Edge::storeShape(const std::string& edgeID, PositionVector& shape) {
     394        20375 :     const MSEdge* const e = getEdge(edgeID);
     395        40922 :     for (const MSLane* lane : e->getLanes()) {
     396              :         copy(lane->getShape().begin(), lane->getShape().end(), back_inserter(shape));
     397              :     }
     398        20375 : }
     399              : 
     400              : 
     401              : std::shared_ptr<VariableWrapper>
     402          273 : Edge::makeWrapper() {
     403          273 :     return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
     404              : }
     405              : 
     406              : 
     407              : bool
     408        14792 : Edge::handleVariable(const std::string& objID, const int variable, VariableWrapper* wrapper, tcpip::Storage* paramData) {
     409        14792 :     switch (variable) {
     410          147 :         case TRACI_ID_LIST:
     411          147 :             return wrapper->wrapStringList(objID, variable, getIDList());
     412           14 :         case ID_COUNT:
     413           14 :             return wrapper->wrapInt(objID, variable, getIDCount());
     414           74 :         case VAR_EDGE_TRAVELTIME:
     415          148 :             return wrapper->wrapDouble(objID, variable, getAdaptedTraveltime(objID, StoHelp::readTypedDouble(*paramData)));
     416           38 :         case VAR_EDGE_EFFORT:
     417           76 :             return wrapper->wrapDouble(objID, variable, getEffort(objID, StoHelp::readTypedDouble(*paramData)));
     418          130 :         case VAR_CURRENT_TRAVELTIME:
     419          130 :             return wrapper->wrapDouble(objID, variable, getTraveltime(objID));
     420           12 :         case VAR_WAITING_TIME:
     421           12 :             return wrapper->wrapDouble(objID, variable, getWaitingTime(objID));
     422        13431 :         case LAST_STEP_PERSON_ID_LIST:
     423        13431 :             return wrapper->wrapStringList(objID, variable, getLastStepPersonIDs(objID));
     424           50 :         case LAST_STEP_VEHICLE_ID_LIST:
     425           50 :             return wrapper->wrapStringList(objID, variable, getLastStepVehicleIDs(objID));
     426           15 :         case VAR_CO2EMISSION:
     427           15 :             return wrapper->wrapDouble(objID, variable, getCO2Emission(objID));
     428           15 :         case VAR_COEMISSION:
     429           15 :             return wrapper->wrapDouble(objID, variable, getCOEmission(objID));
     430           15 :         case VAR_HCEMISSION:
     431           15 :             return wrapper->wrapDouble(objID, variable, getHCEmission(objID));
     432           15 :         case VAR_PMXEMISSION:
     433           15 :             return wrapper->wrapDouble(objID, variable, getPMxEmission(objID));
     434           15 :         case VAR_NOXEMISSION:
     435           15 :             return wrapper->wrapDouble(objID, variable, getNOxEmission(objID));
     436           15 :         case VAR_FUELCONSUMPTION:
     437           15 :             return wrapper->wrapDouble(objID, variable, getFuelConsumption(objID));
     438           15 :         case VAR_NOISEEMISSION:
     439           15 :             return wrapper->wrapDouble(objID, variable, getNoiseEmission(objID));
     440           11 :         case VAR_ELECTRICITYCONSUMPTION:
     441           11 :             return wrapper->wrapDouble(objID, variable, getElectricityConsumption(objID));
     442          377 :         case LAST_STEP_VEHICLE_NUMBER:
     443          377 :             return wrapper->wrapInt(objID, variable, getLastStepVehicleNumber(objID));
     444           45 :         case LAST_STEP_MEAN_SPEED:
     445           45 :             return wrapper->wrapDouble(objID, variable, getLastStepMeanSpeed(objID));
     446           23 :         case VAR_MAXSPEED:
     447           23 :             return wrapper->wrapDouble(objID, variable, getMaxSpeed(objID));
     448           14 :         case VAR_FRICTION:
     449           14 :             return wrapper->wrapDouble(objID, variable, getMeanFriction(objID));
     450           18 :         case LAST_STEP_OCCUPANCY:
     451           18 :             return wrapper->wrapDouble(objID, variable, getLastStepOccupancy(objID));
     452           15 :         case LAST_STEP_VEHICLE_HALTING_NUMBER:
     453           15 :             return wrapper->wrapInt(objID, variable, getLastStepHaltingNumber(objID));
     454           15 :         case LAST_STEP_LENGTH:
     455           15 :             return wrapper->wrapDouble(objID, variable, getLastStepLength(objID));
     456           12 :         case VAR_LANE_INDEX:
     457           12 :             return wrapper->wrapInt(objID, variable, getLaneNumber(objID));
     458           12 :         case VAR_NAME:
     459           24 :             return wrapper->wrapString(objID, variable, getStreetName(objID));
     460           38 :         case VAR_PENDING_VEHICLES:
     461           38 :             return wrapper->wrapStringList(objID, variable, getPendingVehicles(objID));
     462           14 :         case VAR_ANGLE:
     463           28 :             return wrapper->wrapDouble(objID, variable, getAngle(objID, StoHelp::readTypedDouble(*paramData)));
     464           11 :         case FROM_JUNCTION:
     465           22 :             return wrapper->wrapString(objID, variable, getFromJunction(objID));
     466           11 :         case TO_JUNCTION:
     467           22 :             return wrapper->wrapString(objID, variable, getToJunction(objID));
     468           62 :         case VAR_BIDI:
     469          124 :             return wrapper->wrapString(objID, variable, getBidiEdge(objID));
     470           60 :         case VAR_PARAMETER:
     471          120 :             return wrapper->wrapString(objID, variable, getParameter(objID, StoHelp::readTypedString(*paramData)));
     472           47 :         case VAR_PARAMETER_WITH_KEY:
     473           94 :             return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, StoHelp::readTypedString(*paramData)));
     474              :         default:
     475              :             return false;
     476              :     }
     477              : }
     478              : 
     479              : }
     480              : 
     481              : 
     482              : /****************************************************************************/
        

Generated by: LCOV version 2.0-1