MSRailSignalControl.cpp

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Centralized services for rail signal control (Singleton)
/****************************************************************************/
#include <config.h>
 
#include <cassert>
#include <utility>
#include <vector>
#include <bitset>
#include <microsim/MSNet.h>
#include <microsim/MSRoute.h>
#include <microsim/MSEdge.h>
#include <microsim/MSLane.h>
#include "MSRailSignal.h"
#include "MSRailSignalConstraint.h"
#include "MSDriveWay.h"
#include "MSRailSignalControl.h"
 
 
//#define DEBUG_BUILD_DEADLOCK_CHECK
 
// ===========================================================================
// static value definitions
// ===========================================================================
MSRailSignalControl* MSRailSignalControl::myInstance(nullptr);
SVCPermissions MSRailSignalControl::mySignalizedClasses(SVC_UNSPECIFIED);
SVCPermissions MSRailSignalControl::myMBClasses(SVC_UNSPECIFIED);
 
// ===========================================================================
// method definitions
// ===========================================================================
MSRailSignalControl::MSRailSignalControl():
    myMaxTrainLength(OptionsCont::getOptions().getFloat("railway.max-train-length"))
{}
 
MSRailSignalControl&
MSRailSignalControl::getInstance() {
    if (myInstance == nullptr) {
        myInstance = new MSRailSignalControl();
        MSNet::getInstance()->addVehicleStateListener(myInstance);
    }
    return *myInstance;
}
 
void
MSRailSignalControl::cleanup() {
    delete myInstance;
    myInstance = nullptr;
}
 
void
MSRailSignalControl::clearState() {
    if (myInstance != nullptr) {
        myInstance->myDriveWayCompatibility.clear();
        myInstance->myDriveWaySucc.clear();
        myInstance->myDriveWayPred.clear();
        myInstance->myWrittenDeadlocks.clear();
        myInstance->mySignalDeadlocks.clear();
        myInstance->myLoadedDeadlocks.clear();
        //myInstance->myActiveSignals.clear();
    }
}
 
 
MSRailSignalControl::~MSRailSignalControl() {
}
 
void
MSRailSignalControl::vehicleStateChanged(const SUMOVehicle* const vehicle, MSNet::VehicleState to, const std::string& /*info*/) {
    if (vehicle->isRail()) {
        std::string dummyMsg;
        if ((to == MSNet::VehicleState::BUILT && (!vehicle->getParameter().wasSet(VEHPARS_FORCE_REROUTE) || vehicle->hasValidRoute(dummyMsg)))
                || to == MSNet::VehicleState::NEWROUTE) {
            // @note we could delay initialization until the departure time
            if (vehicle->getEdge()->getFunction() != SumoXMLEdgeFunc::CONNECTOR && isRailwayOrShared(vehicle->getEdge()->getPermissions())) {
                MSRailSignal::initDriveWays(vehicle, to == MSNet::VehicleState::NEWROUTE);
            }
        }
        if (to == MSNet::VehicleState::BUILT) {
            myMaxTrainLength = MAX2(myMaxTrainLength, vehicle->getLength());
        }
    }
}
 
 
void
MSRailSignalControl::addSignal(MSRailSignal* signal) {
    mySignals.push_back(signal);
    for (const auto& links : signal->getLinks()) {
        for (const MSLink* link : links) {
            mySignalizedClasses |= (link->getPermissions() & myMBClasses);
        }
    }
}
 
 
void
MSRailSignalControl::addWaitRelation(const SUMOVehicle* waits, const MSRailSignal* rs, const SUMOVehicle* reason, MSRailSignalConstraint* constraint) {
    //std::cout << time2string(SIMSTEP) << " addWaitRelation waits=" << waits->getID() << " foe=" << reason->getID() << "\n";
    myWaitRelations[waits] = WaitRelation(rs, reason, constraint);
}
 
 
bool
MSRailSignalControl::haveDeadlock(const SUMOVehicle* veh) const {
    std::set<const SUMOVehicle*> seen;
    std::vector<WaitRelation> list;
    const SUMOVehicle* cur = veh;
    std::vector<MSRailSignalConstraint*> constraints;
    std::vector<const SUMOVehicle*> constraintBlocked;
    std::vector<const MSRailSignal*> constraintSignals;
    //std::cout << time2string(SIMSTEP) << " haveDeadlock veh=" << veh->getID() << "\n";
    while (seen.count(cur) == 0) {
        auto it = myWaitRelations.find(cur);
        if (it != myWaitRelations.end()) {
            if (it->second.constraint != nullptr) {
                constraints.push_back(it->second.constraint);
                constraintBlocked.push_back(cur);
                constraintSignals.push_back(it->second.railSignal);
            }
            seen.insert(cur);
            list.push_back(it->second);
            cur = it->second.foe;
        } else {
            return false;
        }
    }
    if (cur == veh) {
        const bool newDeadlock = myWrittenDeadlocks.count(seen) == 0;
        myWrittenDeadlocks.insert(seen);
        const OptionsCont& oc = OptionsCont::getOptions();
        MSRailSignalConstraint* resolved = nullptr;
        const SUMOVehicle* resolvedUnblocked = nullptr;
        const MSRailSignal* resolvedSignal = nullptr;
        if (!constraints.empty() && oc.getBool("time-to-teleport.remove-constraint")) {
            resolved = constraints.front();
            if (newDeadlock) {
                std::vector<std::string> vehicles;
                for (auto item : list) {
                    vehicles.push_back(item.foe->getID());
                }
                WRITE_WARNINGF("Deactivating constraint to resolve deadlock between vehicles % at time %.", toString(vehicles), time2string(SIMSTEP));
                resolved->setActive(false);
                resolvedUnblocked = constraintBlocked.front();
                resolvedSignal = constraintSignals.front();
            }
        }
 
        if (oc.isSet("deadlock-output")) {
            if (newDeadlock) {
                myWrittenDeadlocks.insert(seen);
                std::vector<std::string> signals;
                std::vector<std::string> vehicles;
                std::vector<std::string> tripIDs;
                for (auto item : list) {
                    signals.push_back(item.railSignal == nullptr ? "INSERTION" : item.railSignal->getID());
                    vehicles.push_back(item.foe->getID());
                    tripIDs.push_back(item.foe->getParameter().getParameter("tripId", item.foe->getID()));
                }
                // rotate signals so their are aligned with the vehicle waiting
                // at that signal instead of the foe that is blocking the signal
                std::rotate(signals.begin(), signals.begin() + 1, signals.end());
                OutputDevice& od = OutputDevice::getDeviceByOption("deadlock-output");
                if (constraints.empty()) {
                    od.openTag(SUMO_TAG_DEADLOCK);
                } else {
                    od.openTag("constraintDeadlock");
                }
                od.writeAttr(SUMO_ATTR_TIME, time2string(SIMSTEP));
                od.writeAttr(SUMO_ATTR_SIGNALS, signals);
                od.writeAttr("vehicles", vehicles);
                if (!constraints.empty()) {
                    od.writeAttr("tripIds", tripIDs);
                }
                if (resolved != nullptr) {
                    od.openTag("resolvedConstraint");
                    od.writeAttr(SUMO_ATTR_ID, resolvedSignal->getID());
                    resolved->write(od, resolvedUnblocked->getParameter().getParameter("tripId", resolvedUnblocked->getID()));
                    od.closeTag();
                }
                for (auto item : list) {
                    int start = item.foe->getRoutePosition();
                    if (!MSGlobals::gUseMesoSim) {
                        const std::vector<MSLane*>& further = dynamic_cast<const MSVehicle*>(item.foe)->getFurtherLanes();
                        start = MAX2(0, start - (int)(MSGlobals::gUsingInternalLanes && MSNet::getInstance()->hasInternalLinks() ? further.size() / 2 : further.size()));
                    }
                    const MSRoute& route = item.foe->getRoute();
                    ConstMSEdgeVector future(route.begin() + start, route.end());
                    od.openTag(SUMO_TAG_ROUTEPART);
                    od.writeAttr(SUMO_ATTR_EDGES, toString(future));
                    od.closeTag();
                }
                od.closeTag();
            }
        }
        return resolved == nullptr;
    } else {
        // it's a deadlock but does not involve veh
        return false;
    }
}
 
 
void
MSRailSignalControl::loadDeadlockCheck(std::vector<const MSRailSignal*> signals) {
    if (MSDriveWay::haveDriveWays()) {
        WRITE_WARNING("Deadlocks should be loaded before any vehicles");
    }
#ifdef DEBUG_BUILD_DEADLOCK_CHECK
    std::cout << "    loadedDeadlockCheck signals=" << toString(signals) << "\n";
#endif
    const int deadlockIndex = (int)myLoadedDeadlocks.size();
    myLoadedDeadlocks.push_back(Deadlock());
    myLoadedDeadlocks.back().signals = signals;
    const int n = (int)signals.size();
    for (int i = 0; i < n; i++) {
        mySignalDeadlocks[signals[i]].push_back(std::make_pair(deadlockIndex, i));
    }
}
 
 
void
MSRailSignalControl::loadDeadlockRoute(const ConstMSEdgeVector& edges) {
    Deadlock& dl = myLoadedDeadlocks.back();
    const int signalIndex = (int)dl.edges.size();
    const MSRailSignal* rs = dl.signals[signalIndex];
    const MSJunction* j = rs->getJunction();
    auto it = edges.begin();
    while (it != edges.end() && (*it)->getToJunction() != j) {
        it++;
    }
    if (it == edges.end()) {
        throw ProcessError("Rail signal junction '" + j->getID() + "' not passed by loaded deadlock edges '" + toString(edges) + "'.");
    }
    const MSEdge* firstSignalEdge = *it;
    // maybe there is an earlier signal, in this case we must look for driveways that start there
    for (auto it2 = edges.begin(); it2 != it; it2++) {
        if ((*it2)->getToJunction()->getType() == SumoXMLNodeType::RAIL_SIGNAL) {
            const MSLink* link = (*it2)->getLanes().front()->getLinkTo((*(it2 + 1))->getLanes().front());
            if (link != nullptr && link->isTLSControlled()) {
                firstSignalEdge = *it2;
                break;
            }
        }
    }
    dl.forwardEnds.push_back(firstSignalEdge);
    dl.edges.push_back(edges);
#ifdef DEBUG_BUILD_DEADLOCK_CHECK
    std::cout << "      loadedDeadlockRoute signal=" << rs->getID() << " signalEdge=" << firstSignalEdge->getID() << " edges=" << toString(edges) << "\n";
#endif
}
 
 
void
MSRailSignalControl::addDrivewayFollower(const MSDriveWay* dw, const MSDriveWay* dw2) {
    //std::cout << " addDrivewayFollower " << dw->getID() << " " << dw2->getID() << "\n";
    myDriveWaySucc[dw].insert(dw2);
    myDriveWayPred[dw2].insert(dw);
}
 
 
void
MSRailSignalControl::addDWDeadlockChecks(const MSRailSignal* rs, MSDriveWay* dw) {
    auto itDL = mySignalDeadlocks.find(rs);
    if (itDL == mySignalDeadlocks.end()) {
        return;
    }
#ifdef DEBUG_BUILD_DEADLOCK_CHECK
    std::cout << "    needsDeadlockChecks? rs=" << rs->getID() << " dw=" << dw->getID() << "\n";
#endif
    // the driveway dw ends at signal rs and could be part of a deadlock.
    // check whether we can form a sequence of driveways that link it with all others (railsignals)
    // findDeadlockFoes calls itself recursively until all circles have been found
    for (const auto& pair : itDL->second) {
        const Deadlock& dl = myLoadedDeadlocks[pair.first];
        std::vector<const MSDriveWay*> deadlockFoes;
        if (dl.edges.empty()) {
            findDeadlockFoes(dw, dl, pair.second, deadlockFoes);
        } else {
            const MSEdge* forwardEnd = dl.forwardEnds[pair.second];
            if (forwardEnd == &dw->getForward().back()->getEdge()) {
                findDeadlockFoesFromRoutes(dw, dl, pair.second, deadlockFoes);
            } else {
                for (MSDriveWay* cand : MSDriveWay::getEndingDriveWays(forwardEnd)) {
                    findDeadlockFoesFromRoutes(cand, dl, pair.second, deadlockFoes);
                }
            }
        }
    }
}
 
 
void
MSRailSignalControl::findDeadlockFoes(const MSDriveWay* dw, const Deadlock& dl, int signalIndex, std::vector<const MSDriveWay*> deadlockFoes) {
    if (deadlockFoes.size() < dl.signals.size()) {
        signalIndex = (signalIndex + 1) % dl.signals.size();
        const MSRailSignal* other = dl.signals[signalIndex];
        const MSJunction* otherJ = other->getJunction();
#ifdef DEBUG_BUILD_DEADLOCK_CHECK
        std::cout << "      findDLfoes dw=" << dw->getID() << " foundFoes=" << toString(deadlockFoes) << " otherRS=" << other->getID() << "\n";
#endif
        deadlockFoes.push_back(dw);
        for (const MSDriveWay* follower : myDriveWaySucc[dw]) {
#ifdef DEBUG_BUILD_DEADLOCK_CHECK
            std::cout << "        follower=" << follower->getID() << " followerFoes=" << toString(follower->getFoes()) << "\n";
#endif
            for (MSDriveWay* foe : follower->getFoes()) {
                if (foe->getForward().back()->getToJunction() == otherJ) {
                    findDeadlockFoes(foe, dl, signalIndex, deadlockFoes);
                } else if (foe->isSubDriveWay() && foe->getParent()->getForward().back()->getToJunction() == otherJ && foe->getParentRemainingLength() < myMaxTrainLength) {
                    // subdriveway-parents where the remaining part is short and thus a long train might reach back onto the subdriveway
                    // @note: technically we do not need to check this in meso because train ends cannot reach into multiple segments
                    // but it wouldn't help to make meso "better" by ignoring this foe relationship
                    findDeadlockFoes(foe->getParent(), dl, signalIndex, deadlockFoes);
                }
            }
        }
    } else {
#ifdef DEBUG_BUILD_DEADLOCK_CHECK
        std::cout << "        add deadlock check dlFoes=" << toString(deadlockFoes) << "\n";;
#endif
        for (const MSDriveWay* dldw : deadlockFoes) {
            if (!dldw->isDepartDriveway()) {
                const MSRailSignal* rs = dynamic_cast<const MSRailSignal*>(dldw->getOrigin()->getTLLogic());
                if (std::find(dl.signals.begin(), dl.signals.end(), rs) != dl.signals.end()) {
                    // moving into dldw frees up another part of the deadlock
                    continue;
                }
            }
            std::vector<const MSDriveWay*> df(deadlockFoes);
            df.erase(std::find(df.begin(), df.end(), dldw));
#ifdef DEBUG_BUILD_DEADLOCK_CHECK
            std::cout << "           dldw=" << dldw->getID() << " df=" << toString(df) << "\n";
#endif
            const_cast<MSDriveWay*>(dldw)->addDWDeadlock(df);
        }
    }
}
 
 
void
MSRailSignalControl::findDeadlockFoesFromRoutes(const MSDriveWay* dw, const Deadlock& dl, int signalIndex, std::vector<const MSDriveWay*> deadlockFoes) {
    // the loaded edges must match the end of the driveway route
    const ConstMSEdgeVector& de = dl.edges[signalIndex];
    const size_t n = de.size();
#ifdef DEBUG_BUILD_DEADLOCK_CHECK
    std::cout << "      findDLfoesFromRoutes dw=" << dw->getID() << " foundFoes=" << toString(deadlockFoes)
        << "\n        dle=" << toString(de)
        << "\n        dwe=" << toString(ConstMSEdgeVector(dw->getRoute().end() - MIN2(n, dw->getRoute().size()), dw->getRoute().end()))
        << "\n";
#endif
    if (dw->getRoute().size() >= n && std::equal(de.begin(), de.end(),
                dw->getRoute().end() - n, dw->getRoute().end())) {
        deadlockFoes.push_back(dw);
        if (deadlockFoes.size() < dl.signals.size()) {
            signalIndex = (signalIndex + 1) % dl.signals.size();
            const MSEdge* forwardEnd = dl.forwardEnds[signalIndex];
            for (MSDriveWay* cand : MSDriveWay::getEndingDriveWays(forwardEnd)) {
                findDeadlockFoesFromRoutes(cand, dl, signalIndex, deadlockFoes);
            }
        } else {
            findDeadlockFoes(dw, dl, signalIndex, deadlockFoes);
        }
    }
}
 
 
void
MSRailSignalControl::notifyApproach(const MSLink* link) {
    const MSRailSignal* rs = dynamic_cast<const MSRailSignal*>(link->getTLLogic());
    assert(rs != nullptr);
    myActiveSignals.insert(const_cast<MSRailSignal*>(rs));
}
 
 
void
MSRailSignalControl::updateSignals(SUMOTime t) {
    UNUSED_PARAMETER(t);
    // there are 4 states for a signal
    // 1. approached and green
    // 2. approached and red
    // 3. not approached and trains could pass
    // 4. not approached and trains coult not pass
    //
    // for understanding conflicts better in sumo-gui, we want to show (3) as green. This
    // means we have to keep updating signals in state (4) until they change to (3)
 
    //std::cout << SIMTIME << " activeSignals=" << myActiveSignals.size() << "\n";
    for (auto it = myActiveSignals.begin(); it != myActiveSignals.end();) {
        MSRailSignal* rs = *it;
        const bool keepActive = rs->updateCurrentPhase();
        // std::cout << SIMTIME << " update " << rs->getID() << " keepActive=" << keepActive << "\n";
        if (rs->isActive()) {
            rs->setTrafficLightSignals(t);
        }
        if (!keepActive) {
            it = myActiveSignals.erase(it);
        } else {
            it++;
        }
    }
}
 
 
/****************************************************************************/