ROMAAssignments.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 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
/****************************************************************************/
// Assignment methods
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/router/SUMOAbstractRouter.h>
#include <utils/common/SUMOTime.h>
 
// ===========================================================================
// class declarations
// ===========================================================================
class RONet;
class ODMatrix;
class Distribution_Points;
class ROEdge;
class ROMAEdge;
class ROVehicle;
 
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class ROMAAssignments {
public:
    ROMAAssignments(const SUMOTime begin, const SUMOTime end, const bool additiveTraffic,
                    const double adaptionFactor, const int maxAlternatives, const bool defaultCapacities,
                    RONet& net, ODMatrix& matrix, SUMOAbstractRouter<ROEdge, ROVehicle>& router,
                    OutputDevice* netloadOutput);
 
    ~ROMAAssignments();
 
    ROVehicle* getDefaultVehicle() const {
        return myDefaultVehicle;
    }
 
    // @brief calculate edge capacity for the given edge
    double getCapacity(const ROEdge* edge) const;
 
    // @brief calculate edge travel time for the given edge and number of vehicles per hour
    double capacityConstraintFunction(const ROEdge* edge, const double flow) const;
 
    // @brief clear effort storage
    void resetFlows();
 
    // @brief Writes the travel times for a single interval
    void writeInterval(const SUMOTime begin, const SUMOTime end);
 
    // @brief incremental method
    void incremental(const int numIter, const bool verbose);
 
    // @brief UE method
    void ue();
 
    // @brief SUE method
    void sue(const int maxOuterIteration, const int maxInnerIteration, const int kPaths, const double penalty, const double tolerance, const std::string routeChoiceMethod);
 
    static double getPenalizedEffort(const ROEdge* const e, const ROVehicle* const v, double t);
 
    static double getPenalizedTT(const ROEdge* const e, const ROVehicle* const v, double t);
 
    static double getTravelTime(const ROEdge* const e, const ROVehicle* const v, double t);
 
private:
    bool addRoute(const ConstROEdgeVector& edges, std::vector<RORoute*>& paths, std::string routeId, double prob);
 
    const ConstROEdgeVector computePath(ODCell* cell, const SUMOTime time = 0, const double probability = 0., SUMOAbstractRouter<ROEdge, ROVehicle>* router = nullptr, bool setBulkMode = false);
 
    void getKPaths(const int kPaths, const double penalty);
 
private:
    const SUMOTime myBegin;
    const SUMOTime myEnd;
    const bool myAdditiveTraffic;
    const double myAdaptionFactor;
    const int myMaxAlternatives;
    const bool myUseDefaultCapacities;
    RONet& myNet;
    ODMatrix& myMatrix;
    SUMOAbstractRouter<ROEdge, ROVehicle>& myRouter;
    static std::map<const ROEdge* const, double> myPenalties;
    ROVehicle* myDefaultVehicle;
    OutputDevice* const myNetloadOutput;
 
#ifdef HAVE_FOX
private:
    class RoutingTask : public MFXWorkerThread::Task {
    public:
        RoutingTask(ROMAAssignments& assign, ODCell* c, const SUMOTime begin, const double linkFlow, const bool setBulkMode = false)
            : myAssign(assign), myCell(c), myBegin(begin), myLinkFlow(linkFlow), mySetBulkMode(setBulkMode) {}
        void run(MFXWorkerThread* context);
    private:
        ROMAAssignments& myAssign;
        ODCell* const myCell;
        const SUMOTime myBegin;
        const double myLinkFlow;
        const bool mySetBulkMode;
    private:
        RoutingTask& operator=(const RoutingTask&) = delete;
    };
#endif
 
 
private:
    ROMAAssignments& operator=(const ROMAAssignments& src) = delete;
 
};