RODFNet Class Reference

#include <RODFNet.h>

Inheritance diagram for RODFNet:

---

Detailed Description

A DFROUTER-network.

Definition at line 48 of file RODFNet.h.

Public Member Functions
void	buildApproachList ()
void	buildDetectorDependencies (RODFDetectorCon &detectors)
void	buildEdgeFlowMap (const RODFDetectorFlows &flows, const RODFDetectorCon &detectors, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset)
void	buildRoutes (RODFDetectorCon &det, bool allEndFollower, bool keepUnfoundEnds, bool includeInBetween, bool keepShortestOnly, int maxFollowingLength) const
void	closeOutput () throw ()
	closes the file output for computed routes
void	computeTypes (RODFDetectorCon &dets, bool sourcesStrict) const
SUMOReal	getAbsPos (const RODFDetector &det) const
const std::vector< std::string > &	getDetectorList (ROEdge *edge) const
const std::map< std::string, ROEdge * > &	getEdgeMap () const
unsigned int	getEdgeNo () const
	Returns the number of edges thenetwork contains.
const ROEdge *	getRandomDestination () const throw ()
	Returns a random edge which may be used as an ending point.
ROEdge *	getRandomDestination () throw ()
	Returns a random edge which may be used as an ending point.
const ROEdge *	getRandomSource () const throw ()
	Returns a random edge which may be used as a starting point.
ROEdge *	getRandomSource () throw ()
	Returns a random edge which may be used as a starting point.
bool	hasDetector (ROEdge *edge) const
bool	hasRestrictions () const
void	mesoJoin (RODFDetectorCon &detectors, RODFDetectorFlows &flows)
void	openOutput (const std::string &filename, bool useAlternatives) throw (IOError)
	Opens the output for computed routes.
void	removeEmptyDetectors (RODFDetectorCon &detectors, RODFDetectorFlows &flows, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset)
void	reportEmptyDetectors (RODFDetectorCon &detectors, RODFDetectorFlows &flows)
void	revalidateFlows (const RODFDetectorCon &detectors, RODFDetectorFlows &flows, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset)
	RODFNet (bool amInHighwayMode) throw ()
	Constructor.
void	setRestrictionFound ()
	~RODFNet () throw ()
	Destructor.
Insertion and retrieval of graph parts
virtual void	addEdge (ROEdge *edge) throw ()
void	addNode (RONode *node) throw ()
ROEdge *	getEdge (const std::string &name) const throw ()
	Retrieves an edge from the network.
RONode *	getNode (const std::string &id) const throw ()
	Retrieves an node from the network.
Insertion and retrieval of vehicle types, vehicles, routes, and route definitions
bool	addRouteDef (RORouteDef *def) throw ()
virtual bool	addVehicle (const std::string &id, ROVehicle *veh) throw ()
virtual bool	addVehicleType (SUMOVTypeParameter *type) throw ()
RORouteDef *	getRouteDef (const std::string &name) const throw ()
	Returns the named route definition.
SUMOVTypeParameter *	getVehicleTypeSecure (const std::string &id) throw ()
	Retrieves the named vehicle type.
Processing stored vehicle definitions
virtual bool	furtherStored ()
	Returns the information whether further vehicles are stored.
SUMOTime	saveAndRemoveRoutesUntil (OptionsCont &options, SUMOAbstractRouter< ROEdge, ROVehicle > &router, SUMOTime time)
	Computes routes described by their definitions and saves them.
Protected Member Functions
void	buildDetectorEdgeDependencies (RODFDetectorCon &dets) const
void	checkSourceAndDestinations () const
	Initialises the lists of source and destination edges.
bool	computeRoute (OptionsCont &options, SUMOAbstractRouter< ROEdge, ROVehicle > &router, const ROVehicle *const veh)
void	computeRoutesFor (ROEdge *edge, RODFRouteDesc &base, int no, bool keepUnfoundEnds, bool keepShortestOnly, std::vector< ROEdge * > &visited, const RODFDetector &det, RODFRouteCont &into, const RODFDetectorCon &detectors, int maxFollowingLength, std::vector< ROEdge * > &seen) const
ROEdge *	getDetectorEdge (const RODFDetector &det) const
bool	hasApproached (ROEdge *edge) const
bool	hasApproaching (ROEdge *edge) const
bool	hasInBetweenDetectorsOnly (ROEdge *edge, const RODFDetectorCon &detectors) const
bool	hasSourceDetector (ROEdge *edge, const RODFDetectorCon &detectors) const
bool	isDestination (const RODFDetector &det, ROEdge *edge, std::vector< ROEdge * > &seen, const RODFDetectorCon &detectors) const
bool	isDestination (const RODFDetector &det, const RODFDetectorCon &detectors) const
bool	isFalseSource (const RODFDetector &det, ROEdge *edge, std::vector< ROEdge * > &seen, const RODFDetectorCon &detectors) const
bool	isFalseSource (const RODFDetector &det, const RODFDetectorCon &detectors) const
bool	isSource (const RODFDetector &det, ROEdge *edge, std::vector< ROEdge * > &seen, const RODFDetectorCon &detectors, bool strict) const
bool	isSource (const RODFDetector &det, const RODFDetectorCon &detectors, bool strict) const
void	revalidateFlows (const RODFDetector *detector, RODFDetectorFlows &flows, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset)
Protected Attributes
std::vector< ROEdge * >	myDestinationEdges
	List of destination edges.
unsigned int	myDiscardedRouteNo
	The number of discarded routes.
NamedObjectCont< ROEdge * >	myEdges
	Known edges.
bool	myHaveRestrictions
	Whether the network contains edges which not all vehicles may pass.
NamedObjectCont< RONode * >	myNodes
	Known nodes.
unsigned int	myReadRouteNo
	The number of read routes.
OutputDevice *	myRouteAlternativesOutput
	The file to write the computed route alternatives into.
NamedObjectCont< RORouteDef * >	myRoutes
	Known routes.
OutputDevice *	myRoutesOutput
	The file to write the computed routes into.
std::vector< ROEdge * >	mySourceEdges
	List of source edges.
ROVehicleCont	myVehicles
	Known vehicles.
NamedObjectCont < SUMOVTypeParameter * >	myVehicleTypes
	Known vehicle types.
std::set< std::string >	myVehIDs
	Known vehicle ids.
unsigned int	myWrittenRouteNo
	The number of written routes.
Private Attributes
bool	myAmInHighwayMode
std::map< ROEdge *, std::vector< ROEdge * > >	myApproachedEdges
	Map of edge name->list of names of edges approached by this edge.
std::map< ROEdge *, std::vector< ROEdge * > >	myApproachingEdges
	Map of edge name->list of names of this edge approaching edges.
std::map< std::string, ROEdge * >	myDetectorEdges
std::map< ROEdge *, std::vector< std::string > >	myDetectorsOnEdges
std::vector< std::string >	myDisallowedEdges
	List of ids of edges that shall not be used.
size_t	myInBetweenNumber
size_t	myInvalidNumber
bool	myKeepTurnarounds
size_t	mySinkNumber
size_t	mySourceNumber
Data Structures
class	DFRouteDescByTimeComperator
struct	IterationEdge

---

Constructor & Destructor Documentation

RODFNet::RODFNet

(

bool

amInHighwayMode

)

throw ()

Constructor.

Parameters:

[in]

amInHighwayMode

Whether search for following edges shall stop at slow edges

Definition at line 50 of file RODFNet.cpp.

References OptionsCont::getBool(), OptionsCont::getOptions(), and OptionsCont::getStringVector().

        : RONet(), myAmInHighwayMode(amInHighwayMode),
        mySourceNumber(0), mySinkNumber(0), myInBetweenNumber(0), myInvalidNumber(0) {
    myDisallowedEdges = OptionsCont::getOptions().getStringVector("disallowed-edges");
    myKeepTurnarounds = OptionsCont::getOptions().getBool("keep-turnarounds");
}

RODFNet::~RODFNet

(

)

throw ()

Destructor.

Definition at line 58 of file RODFNet.cpp.

                          {
}

---

Member Function Documentation

void RONet::addEdge

(

ROEdge *

edge

)

throw () [virtual, inherited]

Definition at line 76 of file RONet.cpp.

References NamedObjectCont< T >::add(), MsgHandler::getErrorInstance(), MsgHandler::inform(), and RONet::myEdges.

Referenced by RONetHandler::parseDistrict(), and RONetHandler::parseEdge().

                                   {
    if (!myEdges.add(edge->getID(), edge)) {
        MsgHandler::getErrorInstance()->inform("The edge '" + edge->getID() + "' occurs at least twice.");
        delete edge;
    }
}

void RONet::addNode

(

RONode *

node

)

throw () [inherited]

Definition at line 85 of file RONet.cpp.

References NamedObjectCont< T >::add(), MsgHandler::getErrorInstance(), MsgHandler::inform(), and RONet::myNodes.

Referenced by RONetHandler::parseEdge(), and RONetHandler::parseJunction().

                                   {
    if (!myNodes.add(node->getID(), node)) {
        MsgHandler::getErrorInstance()->inform("The node '" + node->getID() + "' occurs at least twice.");
        delete node;
    }
}

bool RONet::addRouteDef

(

RORouteDef *

def

)

throw () [inherited]

Definition at line 94 of file RONet.cpp.

References NamedObjectCont< T >::add(), and RONet::myRoutes.

Referenced by RORDGenerator_ODAmounts::FlowDef::addSingleRoute(), RORDLoader_TripDefs::myEndElement(), RORDLoader_SUMOBase::myEndElement(), and RORDGenerator_ODAmounts::myEndFlowAmountDef().

                                          {
    return myRoutes.add(def->getID(), def);
}

bool RONet::addVehicle	(	const std::string &	id,
		ROVehicle *	veh
	)			throw () [virtual, inherited]

Definition at line 163 of file RONet.cpp.

References ROVehicleCont::add(), MsgHandler::getErrorInstance(), MsgHandler::inform(), RONet::myReadRouteNo, RONet::myVehicles, and RONet::myVehIDs.

Referenced by RORDGenerator_ODAmounts::FlowDef::addSingleRoute(), RORDLoader_SUMOBase::closeVehicle(), and RORDLoader_TripDefs::myEndElement().

                                                             {
    if (myVehIDs.find(id)==myVehIDs.end()&&myVehicles.add(id, veh)) {
        myVehIDs.insert(id);
        myReadRouteNo++;
        return true;
    }
    MsgHandler::getErrorInstance()->inform("The vehicle '" + id + "' occurs at least twice.");
    return false;
}

bool RONet::addVehicleType

(

SUMOVTypeParameter *

type

)

throw () [virtual, inherited]

Definition at line 152 of file RONet.cpp.

References NamedObjectCont< T >::add(), MsgHandler::getErrorInstance(), MsgHandler::inform(), and RONet::myVehicleTypes.

Referenced by RONet::getVehicleTypeSecure(), RORDLoader_TripDefs::myEndElement(), and RORDLoader_SUMOBase::myEndElement().

                                                      {
    if (!myVehicleTypes.add(type->id, type)) {
        MsgHandler::getErrorInstance()->inform("The vehicle type '" + type->id + "' occurs at least twice.");
        delete type;
        return false;
    }
    return true;
}

void RODFNet::buildApproachList

(

)

Definition at line 63 of file RODFNet.cpp.

References RONet::getEdgeMap(), ROEdge::getFollower(), ROEdge::getFromNode(), ROEdge::getID(), ROEdge::getNoFollowing(), ROEdge::getToNode(), myApproachedEdges, myApproachingEdges, myDisallowedEdges, and myKeepTurnarounds.

Referenced by main().

                           {
    const std::map<std::string, ROEdge*> &edges = getEdgeMap();
    for (std::map<std::string, ROEdge*>::const_iterator rit = edges.begin(); rit != edges.end(); ++rit) {
        ROEdge *ce = (*rit).second;
        unsigned int i = 0;
        unsigned int length_size = ce->getNoFollowing();
        for (i=0; i<length_size; i++) {
            ROEdge *help = ce->getFollower(i);
            if (find(myDisallowedEdges.begin(), myDisallowedEdges.end(), help->getID())!=myDisallowedEdges.end()) {
                // edges in sinks will not be used
                continue;
            }
            if (!myKeepTurnarounds && help->getToNode()==ce->getFromNode()) {
                // do not use turnarounds
                continue;
            }
            // add the connection help->ce to myApproachingEdges
            if (myApproachingEdges.find(help)==myApproachingEdges.end()) {
                myApproachingEdges[help] = std::vector<ROEdge*>();
            }
            myApproachingEdges[help].push_back(ce);
            // add the connection ce->help to myApproachingEdges
            if (myApproachedEdges.find(ce)==myApproachedEdges.end()) {
                myApproachedEdges[ce] = std::vector<ROEdge*>();
            }
            myApproachedEdges[ce].push_back(help);
        }
    }
}

void RODFNet::buildDetectorDependencies

(

RODFDetectorCon &

detectors

)

Definition at line 1052 of file RODFNet.cpp.

References buildDetectorEdgeDependencies(), RODFDetectorCon::getDetector(), RODFDetector::getRouteVector(), RODFDetector::hasRoutes(), myDetectorEdges, and myDetectorsOnEdges.

Referenced by startComputation().

                                                             {
    // !!! this will not work when several detectors are lying on the same edge on different positions


    buildDetectorEdgeDependencies(detectors);
    // for each detector, compute the lists of predecessor and following detectors
    std::map<std::string, ROEdge*>::const_iterator i;
    for (i=myDetectorEdges.begin(); i!=myDetectorEdges.end(); ++i) {
        const RODFDetector &det = detectors.getDetector((*i).first);
        if (!det.hasRoutes()) {
            continue;
        }
        // mark current detectors
        std::vector<RODFDetector*> last;
        {
            const std::vector<std::string> &detNames = myDetectorsOnEdges.find((*i).second)->second;
            for (std::vector<std::string>::const_iterator j=detNames.begin(); j!=detNames.end(); ++j) {
                last.push_back((RODFDetector*) &detectors.getDetector(*j));
            }
        }
        // iterate over the current detector's routes
        const std::vector<RODFRouteDesc> &routes = det.getRouteVector();
        for (std::vector<RODFRouteDesc>::const_iterator j=routes.begin(); j!=routes.end(); ++j) {
            const std::vector<ROEdge*> &edges2Pass = (*j).edges2Pass;
            for (std::vector<ROEdge*>::const_iterator k=edges2Pass.begin()+1; k!=edges2Pass.end(); ++k) {
                if (myDetectorsOnEdges.find(*k)!=myDetectorsOnEdges.end()) {
                    const std::vector<std::string> &detNames = myDetectorsOnEdges.find(*k)->second;
                    // ok, consecutive detector found
                    for (std::vector<RODFDetector*>::iterator l=last.begin(); l!=last.end(); ++l) {
                        // mark as follower of current
                        for (std::vector<std::string>::const_iterator m=detNames.begin(); m!=detNames.end(); ++m) {
                            ((RODFDetector*) &detectors.getDetector(*m))->addPriorDetector((RODFDetector*) &(*l));
                            (*l)->addFollowingDetector((RODFDetector*) &detectors.getDetector(*m));
                        }
                    }
                    last.clear();
                    for (std::vector<std::string>::const_iterator m=detNames.begin(); m!=detNames.end(); ++m) {
                        last.push_back((RODFDetector*) &detectors.getDetector(*m));
                    }
                }
            }
        }
    }
}

void RODFNet::buildDetectorEdgeDependencies

(

RODFDetectorCon &

dets

)

const [protected]

Definition at line 95 of file RODFNet.cpp.

References getDetectorEdge(), RODFDetectorCon::getDetectors(), myDetectorEdges, and myDetectorsOnEdges.

Referenced by buildDetectorDependencies(), buildRoutes(), computeTypes(), and mesoJoin().

                                                                     {
    myDetectorsOnEdges.clear();
    myDetectorEdges.clear();
    const std::vector<RODFDetector*> &dets = detcont.getDetectors();
    {
        for (std::vector<RODFDetector*>::const_iterator i=dets.begin(); i!=dets.end(); ++i) {
            ROEdge *e = getDetectorEdge(**i);

            if (myDetectorsOnEdges.find(e)==myDetectorsOnEdges.end()) {
                myDetectorsOnEdges[e] = std::vector<std::string>();
            }
            myDetectorsOnEdges[e].push_back((*i)->getID());

            myDetectorEdges[(*i)->getID()] = e;
        }
    }
}

void RODFNet::buildEdgeFlowMap	(	const RODFDetectorFlows &	flows,
		const RODFDetectorCon &	detectors,
		SUMOTime	startTime,
		SUMOTime	endTime,
		SUMOTime	stepOffset
	)

Definition at line 986 of file RODFNet.cpp.

References FlowDef::fLKW, RODFDetectorCon::getDetector(), RODFDetectorFlows::getFlowDefs(), RODFDetector::getPos(), FlowDef::isLKW, RODFDetectorFlows::knows(), MAX2(), myDetectorsOnEdges, FlowDef::qLKW, FlowDef::qPKW, SUMOReal, FlowDef::vLKW, and FlowDef::vPKW.

Referenced by startComputation().

                                               {
    std::map<ROEdge*, std::vector<std::string> >::iterator i;
    for (i=myDetectorsOnEdges.begin(); i!=myDetectorsOnEdges.end(); ++i) {
        ROEdge *into = (*i).first;
        const std::vector<std::string> &dets = (*i).second;
        std::map<SUMOReal, std::vector<std::string> > cliques;
        size_t maxCliqueSize = 0;
        for (std::vector<std::string>::const_iterator j=dets.begin(); j!=dets.end(); ++j) {
            if (!flows.knows(*j)) {
                continue;
            }
            const RODFDetector &det = detectors.getDetector(*j);
            bool found = false;
            for (std::map<SUMOReal, std::vector<std::string> >::iterator k=cliques.begin(); !found&&k!=cliques.end(); ++k) {
                if (fabs((*k).first-det.getPos())<1) {
                    (*k).second.push_back(*j);
                    maxCliqueSize = MAX2(maxCliqueSize, (*k).second.size());
                    found = true;
                }
            }
            if (!found) {
                cliques[det.getPos()] = std::vector<std::string>();
                cliques[det.getPos()].push_back(*j);
                maxCliqueSize = MAX2(maxCliqueSize, (size_t) 1);
            }
        }
        std::vector<std::string> firstClique;
        for (std::map<SUMOReal, std::vector<std::string> >::iterator m=cliques.begin(); firstClique.size()==0&&m!=cliques.end(); ++m) {
            if ((*m).second.size()==maxCliqueSize) {
                firstClique = (*m).second;
            }
        }
        std::vector<FlowDef> mflows; // !!! reserve
        SUMOTime t;
        for (t=startTime; t<endTime; t+=stepOffset) {
            FlowDef fd;
            fd.qPKW = 0;
            fd.qLKW = 0;
            fd.vLKW = 0;
            fd.vPKW = 0;
            fd.fLKW = 0;
            fd.isLKW = 0;
            mflows.push_back(fd);
        }
        for (std::vector<std::string>::iterator l=firstClique.begin(); l!=firstClique.end(); ++l) {
            const std::vector<FlowDef> &dflows = flows.getFlowDefs(*l);
            for (t=startTime; t<endTime; t+=stepOffset) {
                const FlowDef &srcFD = dflows[(int)(t/stepOffset) - startTime];
                FlowDef &fd = mflows[(int)(t/stepOffset) - startTime];
                fd.qPKW += srcFD.qPKW;
                fd.qLKW += srcFD.qLKW;
                fd.vLKW += (srcFD.vLKW / (SUMOReal) firstClique.size());
                fd.vPKW += (srcFD.vPKW / (SUMOReal) firstClique.size());
                fd.fLKW += (srcFD.fLKW / (SUMOReal) firstClique.size());
                fd.isLKW += (srcFD.isLKW / (SUMOReal) firstClique.size());
            }
        }
        static_cast<RODFEdge*>(into)->setFlows(mflows);
    }
}

void RODFNet::buildRoutes	(	RODFDetectorCon &	det,
		bool	allEndFollower,
		bool	keepUnfoundEnds,
		bool	includeInBetween,
		bool	keepShortestOnly,
		int	maxFollowingLength
	)			const

!!;

!!routes->removeIllegal(illegals);

!!;

Definition at line 350 of file RODFNet.cpp.

References RODFRouteCont::addAllEndFollower(), BETWEEN_DETECTOR, buildDetectorEdgeDependencies(), computeRoutesFor(), RODFRouteDesc::distance, RODFRouteDesc::distance2Last, RODFRouteDesc::duration2Last, RODFRouteDesc::duration_2, RODFRouteDesc::edges2Pass, RODFRouteDesc::endDetectorEdge, RODFRouteDesc::factor, RODFRouteCont::get(), RODFDetectorCon::getDetector(), getDetectorEdge(), RODFDetectorCon::getDetectors(), ROEdge::getLength(), ROEdge::getSpeed(), RODFDetector::getType(), RODFRouteDesc::lastDetectorEdge, myDetectorsOnEdges, RODFRouteDesc::overallProb, SOURCE_DETECTOR, and SUMOReal.

Referenced by startComputation().

                                                                          {
    /*
    std::vector<std::vector<ROEdge*> > illegals;
    std::vector<ROEdge*> i1;
    i1.push_back(getEdge("-51140604"));
    i1.push_back(getEdge("-51140594"));
    i1.push_back(getEdge("51140072"));
    i1.push_back(getEdge("51140612"));
    illegals.push_back(i1);
    std::vector<ROEdge*> i2;
    i2.push_back(getEdge("-51047761"));
    i2.push_back(getEdge("-51047760"));
    i2.push_back(getEdge("51047759"));
    i2.push_back(getEdge("51047758"));
    illegals.push_back(i2);
    std::vector<ROEdge*> i3;
    i3.push_back(getEdge("-51049672"));
    i3.push_back(getEdge("-51049675"));
    i3.push_back(getEdge("51049662"));
    i3.push_back(getEdge("51049676"));
    illegals.push_back(i3);
    std::vector<ROEdge*> i4;
    i4.push_back(getEdge("-51069817"));
    i4.push_back(getEdge("-51069812"));
    i4.push_back(getEdge("51069813"));
    i4.push_back(getEdge("51069815"));
    illegals.push_back(i4);
    std::vector<ROEdge*> i5;
    i5.push_back(getEdge("50872831"));
    i5.push_back(getEdge("-50872833"));
    i5.push_back(getEdge("-50872829"));
    i5.push_back(getEdge("572267133"));
    illegals.push_back(i5);
    std::vector<ROEdge*> i6;
    i6.push_back(getEdge("-51066847"));
    i6.push_back(getEdge("-51066836"));
    i6.push_back(getEdge("51066830"));
    i6.push_back(getEdge("51066846"));
    illegals.push_back(i6);
    */
    // build needed information first
    buildDetectorEdgeDependencies(detcont);
    // then build the routes
    std::map<ROEdge*, RODFRouteCont * > doneEdges;
    const std::vector< RODFDetector*> &dets = detcont.getDetectors();
    for (std::vector< RODFDetector*>::const_iterator i=dets.begin(); i!=dets.end(); ++i) {
        if ((*i)->getType()!=SOURCE_DETECTOR) {
            // do not build routes for other than sources
            //continue;
        }
        ROEdge *e = getDetectorEdge(**i);
        if (doneEdges.find(e)!=doneEdges.end()) {
            // use previously build routes
            (*i)->addRoutes(new RODFRouteCont(*doneEdges[e]));
            continue;
        }
        std::vector<ROEdge*> seen;
        RODFRouteCont *routes = new RODFRouteCont();
        doneEdges[e] = routes;
        RODFRouteDesc rd;
        rd.edges2Pass.push_back(e);
        rd.duration_2 = (e->getLength()/e->getSpeed());
        rd.endDetectorEdge = 0;
        rd.lastDetectorEdge = 0;
        rd.distance = e->getLength();
        rd.distance2Last = 0;
        rd.duration2Last = 0;

        rd.overallProb = 0;

        std::vector<ROEdge*> visited;
        visited.push_back(e);
        computeRoutesFor(e, rd, 0, keepUnfoundEnds, keepShortestOnly,
                         visited, **i, *routes, detcont, maxFollowingLength, seen);
        if (allEndFollower) {
            routes->addAllEndFollower();
        }
        (*i)->addRoutes(routes);

        // add routes to in-between detectors if wished
        if (includeInBetween) {
            // go through the routes
            const std::vector<RODFRouteDesc> &r = routes->get();
            for (std::vector<RODFRouteDesc>::const_iterator j=r.begin(); j!=r.end(); ++j) {
                const RODFRouteDesc &mrd = *j;
                SUMOReal duration = mrd.duration_2;
                SUMOReal distance = mrd.distance;
                // go through each route's edges
                std::vector<ROEdge*>::const_iterator routeend = mrd.edges2Pass.end();
                for (std::vector<ROEdge*>::const_iterator k=mrd.edges2Pass.begin(); k!=routeend; ++k) {
                    // check whether any detectors lies on the current edge
                    if (myDetectorsOnEdges.find(*k)==myDetectorsOnEdges.end()) {
                        duration -= (*k)->getLength()/(*k)->getSpeed();
                        distance -= (*k)->getLength();
                        continue;
                    }
                    // get the detectors
                    const std::vector<std::string> &dets = myDetectorsOnEdges.find(*k)->second;
                    // go through the detectors
                    for (std::vector<std::string>::const_iterator l=dets.begin(); l!=dets.end(); ++l) {
                        const RODFDetector &m = detcont.getDetector(*l);
                        if (m.getType()==BETWEEN_DETECTOR) {
                            RODFRouteDesc nrd;
                            copy(k, routeend, back_inserter(nrd.edges2Pass));
                            nrd.duration_2 = duration;
                            nrd.endDetectorEdge = mrd.endDetectorEdge;
                            nrd.lastDetectorEdge = mrd.lastDetectorEdge;
                            nrd.distance = distance;
                            nrd.distance2Last = mrd.distance2Last;
                            nrd.duration2Last = mrd.duration2Last;
                            nrd.overallProb = mrd.overallProb;
                            nrd.factor = mrd.factor;
                            ((RODFDetector&) m).addRoute(nrd);
                        }
                    }
                    duration -= (*k)->getLength()/(*k)->getSpeed();
                    distance -= (*k)->getLength();
                }
            }
        }

    }
}

void RONet::checkSourceAndDestinations

(

)

const [protected, inherited]

Initialises the lists of source and destination edges.

Definition at line 313 of file RONet.cpp.

References ROEdge::ET_SINK, ROEdge::ET_SOURCE, NamedObjectCont< T >::getMyMap(), ROEdge::getType(), RONet::myDestinationEdges, RONet::myEdges, and RONet::mySourceEdges.

Referenced by RONet::getRandomDestination(), and RONet::getRandomSource().

                                        {
    if (myDestinationEdges.size()!=0||mySourceEdges.size()!=0) {
        return;
    }
    const std::map<std::string, ROEdge*> &edges = myEdges.getMyMap();
    for (std::map<std::string, ROEdge*>::const_iterator i=edges.begin(); i!=edges.end(); ++i) {
        ROEdge *e = (*i).second;
        ROEdge::EdgeType type = e->getType();
        // !!! add something like "classified edges only" for using only sources or sinks
        if (type!=ROEdge::ET_SOURCE) {
            myDestinationEdges.push_back(e);
        }
        if (type!=ROEdge::ET_SINK) {
            mySourceEdges.push_back(e);
        }
    }
}

void RONet::closeOutput

(

)

throw () [inherited]

closes the file output for computed routes

Definition at line 116 of file RONet.cpp.

References OutputDevice::close(), RONet::myRouteAlternativesOutput, and RONet::myRoutesOutput.

Referenced by computeRoutes().

                           {
    // end writing
    if (myRoutesOutput!= 0) {
        myRoutesOutput->close();
    }
    // only if opened
    if (myRouteAlternativesOutput!=0) {
        myRouteAlternativesOutput->close();
    }
}

bool RONet::computeRoute	(	OptionsCont &	options,
		SUMOAbstractRouter< ROEdge, ROVehicle > &	router,
		const ROVehicle *const	veh
	)			[protected, inherited]

Definition at line 175 of file RONet.cpp.

References RORouteDef::addAlternative(), RORouteDef::buildCurrentRoute(), OptionsCont::getBool(), ROVehicle::getDepartureTime(), MsgHandler::getErrorInstance(), ROVehicle::getID(), ROVehicle::getRouteDefinition(), MsgHandler::getWarningInstance(), MsgHandler::inform(), ReferencedItem::isSaved(), RORoute::recheckForLoops(), and RORoute::size().

Referenced by RONet::saveAndRemoveRoutesUntil().

                                                 {
    MsgHandler *mh = MsgHandler::getErrorInstance();
    if (options.getBool("continue-on-unbuild")) {
        mh = MsgHandler::getWarningInstance();
    }
    RORouteDef * const routeDef = veh->getRouteDefinition();
    // check if the route definition is valid
    if (routeDef==0) {
        mh->inform("The vehicle '" + veh->getID() + "' has no valid route.");
        return false;
    }
    // check whether the route was already saved
    if (routeDef->isSaved()) {
        return true;
    }
    //
    RORoute *current =
        routeDef->buildCurrentRoute(router, veh->getDepartureTime(), *veh);
    if (current==0||current->size()==0) {
        delete current;
        return false;
    }
    // check whether we have to evaluate the route for not containing loops
    if (options.getBool("remove-loops")) {
        current->recheckForLoops();
    }
    // check whether the route is still valid
    if (current->size()==0) {
        delete current;
        return false;
    }
    // add built route
    routeDef->addAlternative(router, veh, current, veh->getDepartureTime());
    return true;
}

void RODFNet::computeRoutesFor	(	ROEdge *	edge,
		RODFRouteDesc &	base,
		int	no,
		bool	keepUnfoundEnds,
		bool	keepShortestOnly,
		std::vector< ROEdge * > &	visited,
		const RODFDetector &	det,
		RODFRouteCont &	into,
		const RODFDetectorCon &	detectors,
		int	maxFollowingLength,
		std::vector< ROEdge * > &	seen
	)			const [protected]

!!! //toDiscard.push_back(current);

!!

Definition at line 192 of file RODFNet.cpp.

References RODFRouteCont::addRouteDesc(), RODFRouteDesc::distance, RODFRouteDesc::distance2Last, RODFRouteDesc::duration2Last, RODFRouteDesc::duration_2, RODFRouteDesc::edges2Pass, RODFRouteDesc::endDetectorEdge, RODFRouteDesc::factor, getDetectorEdge(), OptionsCont::getFloat(), RODFDetector::getID(), OptionsCont::getOptions(), ROEdge::getSpeed(), MsgHandler::getWarningInstance(), hasApproached(), hasDetector(), hasInBetweenDetectorsOnly(), hasSourceDetector(), MsgHandler::inform(), RODFRouteDesc::lastDetectorEdge, myAmInHighwayMode, myApproachedEdges, RODFRouteDesc::passedNo, RODFRouteCont::removeRouteDesc(), and SUMOReal.

Referenced by buildRoutes().

                                                          {
    std::vector<RODFRouteDesc> unfoundEnds;
    std::priority_queue<RODFRouteDesc, std::vector<RODFRouteDesc>, DFRouteDescByTimeComperator> toSolve;
    std::map<ROEdge*, std::vector<ROEdge*> > dets2Follow;
    dets2Follow[edge] = std::vector<ROEdge*>();
    base.passedNo = 0;
    SUMOReal minDist = OptionsCont::getOptions().getFloat("min-distance");
    toSolve.push(base);
    while (!toSolve.empty()) {
        RODFRouteDesc current = toSolve.top();
        toSolve.pop();
        ROEdge *last = *(current.edges2Pass.end()-1);
        if (hasDetector(last)) {
            if (dets2Follow.find(last)==dets2Follow.end()) {
                dets2Follow[last] = std::vector<ROEdge*>();
            }
            for (std::vector<ROEdge*>::reverse_iterator i=current.edges2Pass.rbegin()+1; i!=current.edges2Pass.rend(); ++i) {
                if (hasDetector(*i)) {
                    dets2Follow[*i].push_back(last);
                    break;
                }
            }
        }

        // do not process an edge twice
        if (find(seen.begin(), seen.end(), last)!=seen.end() && keepShortestOnly) {
            continue;
        }
        seen.push_back(last);
        // end if the edge has no further connections
        if (!hasApproached(last)) {
            // ok, no further connections to follow
            current.factor = 1.;
            SUMOReal cdist = current.edges2Pass[0]->getFromNode()->getPosition().distanceTo(current.edges2Pass.back()->getToNode()->getPosition());
            if (minDist<cdist) {
                into.addRouteDesc(current);
            }
            continue;
        }
        // check for passing detectors:
        //  if the current last edge is not the one the detector is placed on ...
        bool addNextNoFurther = false;
        if (last!=getDetectorEdge(det)) {
            // ... if there is a detector ...
            if (hasDetector(last)) {
                if (!hasInBetweenDetectorsOnly(last, detectors)) {
                    // ... and it's not an in-between-detector
                    // -> let's add this edge and the following, but not any further
                    addNextNoFurther = true;
                    current.lastDetectorEdge = last;
                    current.duration2Last = (SUMOTime) current.duration_2;
                    current.distance2Last = current.distance;
                    current.endDetectorEdge = last;
                    if (hasSourceDetector(last, detectors)) {
                    }
                    current.factor = 1.;
                    SUMOReal cdist = current.edges2Pass[0]->getFromNode()->getPosition().distanceTo(current.edges2Pass.back()->getToNode()->getPosition());
                    if (minDist<cdist) {
                        into.addRouteDesc(current);
                    }
                    continue;
                } else {
                    // ... if it's an in-between-detector
                    // -> mark the current route as to be continued
                    current.passedNo = 0;
                    current.duration2Last = (SUMOTime) current.duration_2;
                    current.distance2Last = current.distance;
                    current.lastDetectorEdge = last;
                }
            }
        }
        // check for highway off-ramps
        if (myAmInHighwayMode) {
            // if it's beside the highway...
            if (last->getSpeed()<19.4&&last!=getDetectorEdge(det)) {
                // ... and has more than one following edge
                if (myApproachedEdges.find(last)->second.size()>1) {
                    // -> let's add this edge and the following, but not any further
                    addNextNoFurther = true;
                }

            }
        }
        // check for missing end connections
        if (!addNextNoFurther) {
            // ... if this one would be processed, but already too many edge
            //  without a detector occured
            if (current.passedNo>maxFollowingLength) {
                // mark not to process any further
                MsgHandler::getWarningInstance()->inform("Could not close route for '" + det.getID() + "'");
                unfoundEnds.push_back(current);
                current.factor = 1.;
                SUMOReal cdist = current.edges2Pass[0]->getFromNode()->getPosition().distanceTo(current.edges2Pass.back()->getToNode()->getPosition());
                if (minDist<cdist) {
                    into.addRouteDesc(current);
                }
                continue;
            }
        }
        // ... else: loop over the next edges
        const std::vector<ROEdge*> &appr  = myApproachedEdges.find(last)->second;
        bool hadOne = false;
        for (size_t i=0; i<appr.size(); i++) {
            if (find(current.edges2Pass.begin(), current.edges2Pass.end(), appr[i])!=current.edges2Pass.end()) {
                // do not append an edge twice (do not build loops)
                continue;
            }
            RODFRouteDesc t(current);
            t.duration_2 += (appr[i]->getLength()/appr[i]->getSpeed());
            t.distance += appr[i]->getLength();
            t.edges2Pass.push_back(appr[i]);
            if (!addNextNoFurther) {
                t.passedNo = t.passedNo + 1;
                toSolve.push(t);
            } else {
                if (!hadOne) {
                    t.factor = (SUMOReal) 1. / (SUMOReal) appr.size();
                    SUMOReal cdist = current.edges2Pass[0]->getFromNode()->getPosition().distanceTo(current.edges2Pass.back()->getToNode()->getPosition());
                    if (minDist<cdist) {
                        into.addRouteDesc(t);
                    }
                    hadOne = true;
                }
            }
        }
    }
    //
    if (!keepUnfoundEnds) {
        std::vector<RODFRouteDesc>::iterator i;
        std::vector<const ROEdge*> lastDetEdges;
        for (i=unfoundEnds.begin(); i!=unfoundEnds.end(); ++i) {
            if (find(lastDetEdges.begin(), lastDetEdges.end(), (*i).lastDetectorEdge)==lastDetEdges.end()) {
                lastDetEdges.push_back((*i).lastDetectorEdge);
            } else {
                bool ok = into.removeRouteDesc(*i);
                assert(ok);
            }
        }
    } else {
        // !!! patch the factors
    }
    while (!toSolve.empty()) {
//        RODFRouteDesc d = toSolve.top();
        toSolve.pop();
//        delete d;
    }
}

void RODFNet::computeTypes	(	RODFDetectorCon &	dets,
		bool	sourcesStrict
	)			const

Definition at line 115 of file RODFNet.cpp.

References MsgHandler::beginProcessMsg(), BETWEEN_DETECTOR, buildDetectorEdgeDependencies(), DISCARDED_DETECTOR, MsgHandler::endProcessMsg(), RODFDetectorCon::getDetectors(), MsgHandler::getMessageInstance(), MsgHandler::inform(), isDestination(), isFalseSource(), isSource(), myInBetweenNumber, myInvalidNumber, mySinkNumber, mySourceNumber, SINK_DETECTOR, SOURCE_DETECTOR, toString(), and TYPE_NOT_DEFINED.

Referenced by startComputation().

                                                {
    MsgHandler::getMessageInstance()->beginProcessMsg("Computing detector types...");
    const std::vector< RODFDetector*> &dets = detcont.getDetectors();
    // build needed information. first
    buildDetectorEdgeDependencies(detcont);
    // compute detector types then
    {
        for (std::vector< RODFDetector*>::const_iterator i=dets.begin(); i!=dets.end(); ++i) {
            if (isSource(**i, detcont, sourcesStrict)) {
                (*i)->setType(SOURCE_DETECTOR);
                mySourceNumber++;
            }
            if (isDestination(**i, detcont)) {
                (*i)->setType(SINK_DETECTOR);
                mySinkNumber++;
            }
            if ((*i)->getType()==TYPE_NOT_DEFINED) {
                (*i)->setType(BETWEEN_DETECTOR);
                myInBetweenNumber++;
            }
        }
    }
    // recheck sources
    {
        for (std::vector< RODFDetector*>::const_iterator i=dets.begin(); i!=dets.end(); ++i) {
            if ((*i)->getType()==SOURCE_DETECTOR&&isFalseSource(**i, detcont)) {
                (*i)->setType(DISCARDED_DETECTOR);
                myInvalidNumber++;
                mySourceNumber--;
            }
        }
    }
    // print results
    MsgHandler::getMessageInstance()->endProcessMsg("done.");
    MsgHandler::getMessageInstance()->inform("Computed detector types:");
    MsgHandler::getMessageInstance()->inform(" " + toString(mySourceNumber) + " source detectors");
    MsgHandler::getMessageInstance()->inform(" " + toString(mySinkNumber) + " sink detectors");
    MsgHandler::getMessageInstance()->inform(" " + toString(myInBetweenNumber) + " in-between detectors");
    MsgHandler::getMessageInstance()->inform(" " + toString(myInvalidNumber) + " invalid detectors");
}

bool RONet::furtherStored

(

)

[virtual, inherited]

Returns the information whether further vehicles are stored.

Definition at line 258 of file RONet.cpp.

References RONet::myVehicles, and NamedObjectCont< T >::size().

Referenced by ROLoader::processRoutesStepWise().

                     {
    return myVehicles.size()>0;
}

SUMOReal RODFNet::getAbsPos

(

const RODFDetector &

det

)

const

Definition at line 728 of file RODFNet.cpp.

References getDetectorEdge(), ROEdge::getLength(), and RODFDetector::getPos().

Referenced by isDestination(), and isSource().

                                                {
    if (det.getPos()>=0) {
        return det.getPos();
    }
    return getDetectorEdge(det)->getLength() + det.getPos();
}

ROEdge * RODFNet::getDetectorEdge

(

const RODFDetector &

det

)

const [protected]

Definition at line 683 of file RODFNet.cpp.

References RONet::getEdge(), RODFDetector::getID(), and RODFDetector::getLaneID().

Referenced by buildDetectorEdgeDependencies(), buildRoutes(), computeRoutesFor(), getAbsPos(), isDestination(), isFalseSource(), isSource(), and revalidateFlows().

                                                      {
    std::string edgeName = det.getLaneID();
    edgeName = edgeName.substr(0, edgeName.rfind('_'));
    ROEdge *ret = getEdge(edgeName);
    if (ret==0) {
        throw ProcessError("Edge '" + edgeName + "' used by detector '" + det.getID() + "' is not known.");
    }
    return ret;
}

const std::vector< std::string > & RODFNet::getDetectorList

(

ROEdge *

edge

)

const

Definition at line 722 of file RODFNet.cpp.

References myDetectorsOnEdges.

                                           {
    return myDetectorsOnEdges.find(edge)->second;
}

ROEdge* RONet::getEdge

(

const std::string &

name

)

const throw () [inline, inherited]

Retrieves an edge from the network.

This is not very pretty, but necessary, though, as routes run over instances, not over ids.

Parameters:

[in]

name

The name of the edge to retrieve

Returns:

The named edge if known, otherwise 0

Todo:

Check whether a const pointer may be returned

Definition at line 99 of file RONet.h.

References NamedObjectCont< T >::get(), and RONet::myEdges.

Referenced by ROJTRTurnDefLoader::addToEdge(), ROJTRTurnDefLoader::beginFromEdge(), getDetectorEdge(), RORDLoader_TripDefs::getEdge(), loadJTRDefinitions(), RORDLoader_SUMOBase::myCharacters(), ROJTRTurnDefLoader::myCharacters(), ROJTRTurnDefLoader::myStartElement(), RODFDetectorHandler::myStartElement(), RONetHandler::parseConnectedEdge(), RONetHandler::parseConnectingEdge(), RONetHandler::parseDistrict(), RONetHandler::parseDistrictEdge(), RODFDetectorCon::writeEmitters(), and RODFDetectorCon::writeSpeedTrigger().

                                                         {
        return myEdges.get(name);
    }

const std::map< std::string, ROEdge * > & RONet::getEdgeMap

(

)

const [inherited]

Definition at line 339 of file RONet.cpp.

References NamedObjectCont< T >::getMyMap(), and RONet::myEdges.

Referenced by buildApproachList(), initNet(), and ROLoader::loadWeights().

                        {
    return myEdges.getMyMap();
}

unsigned int RONet::getEdgeNo

(

)

const [inherited]

Returns the number of edges thenetwork contains.

Definition at line 333 of file RONet.cpp.

References RONet::myEdges, and NamedObjectCont< T >::size().

Referenced by computeRoutes(), and ROJTRRouter::ROJTRRouter().

                       {
    return (unsigned int) myEdges.size();
}

RONode* RONet::getNode

(

const std::string &

id

)

const throw () [inline, inherited]

Retrieves an node from the network.

Parameters:

[in]

name

The name of the node to retrieve

Returns:

The named node if known, otherwise 0

Todo:

Check whether a const pointer may be returned

Definition at line 121 of file RONet.h.

References NamedObjectCont< T >::get(), and RONet::myNodes.

Referenced by RONetHandler::parseEdge(), and RONetHandler::parseJunction().

                                                       {
        return myNodes.get(id);
    }

const ROEdge * RONet::getRandomDestination

(

)

const throw () [inherited]

Returns a random edge which may be used as an ending point.

If the list of possible destinations (roads with no successor, "myDestinationEdges") is empty, it is tried to be built, first.

Returns:

A random edge from the list of edges with no successor

Definition at line 301 of file RONet.cpp.

References RONet::checkSourceAndDestinations(), RandHelper::getRandomFrom(), and RONet::myDestinationEdges.

                                          {
    // check whether an edge may be returned
    checkSourceAndDestinations();
    if (myDestinationEdges.size()==0) {
        return 0;
    }
    // choose a random edge
    return RandHelper::getRandomFrom(myDestinationEdges);
}

ROEdge * RONet::getRandomDestination

(

)

throw () [inherited]

Returns a random edge which may be used as an ending point.

If the list of possible destinations (roads with no successor, "myDestinationEdges") is empty, it is tried to be built, first.

Returns:

A random edge from the list of edges with no successor

Definition at line 289 of file RONet.cpp.

References RONet::checkSourceAndDestinations(), RandHelper::getRandomFrom(), and RONet::myDestinationEdges.

                                    {
    // check whether an edge may be returned
    checkSourceAndDestinations();
    if (myDestinationEdges.size()==0) {
        return 0;
    }
    // choose a random edge
    return RandHelper::getRandomFrom(myDestinationEdges);
}

const ROEdge * RONet::getRandomSource

(

)

const throw () [inherited]

Returns a random edge which may be used as a starting point.

If the list of possible sources (roads with no predecessor, "mySourceEdges") is empty, it is tried to be built, first.

Returns:

A random edge from the list of edges with no predecessor

Definition at line 276 of file RONet.cpp.

References RONet::checkSourceAndDestinations(), RandHelper::getRandomFrom(), and RONet::mySourceEdges.

                                     {
    // check whether an edge may be returned
    checkSourceAndDestinations();
    if (mySourceEdges.size()==0) {
        return 0;
    }
    // choose a random edge
    return RandHelper::getRandomFrom(mySourceEdges);
}

ROEdge * RONet::getRandomSource

(

)

throw () [inherited]

Returns a random edge which may be used as a starting point.

If the list of possible source (roads with no predecessor, "mySourceEdges") is empty, it is tried to be built, first.

Returns:

A random edge from the list of edges with no predecessor

Definition at line 264 of file RONet.cpp.

References RONet::checkSourceAndDestinations(), RandHelper::getRandomFrom(), and RONet::mySourceEdges.

                               {
    // check whether an edge may be returned
    checkSourceAndDestinations();
    if (mySourceEdges.size()==0) {
        return 0;
    }
    // choose a random edge
    return RandHelper::getRandomFrom(mySourceEdges);
}

RORouteDef* RONet::getRouteDef

(

const std::string &

name

)

const throw () [inline, inherited]

Returns the named route definition.

Parameters:

[in]

name

The name of the route definition to retrieve

Returns:

The named route definition if known, otherwise 0

Todo:

Check whether a const pointer may be returned

Todo:

Rename myRoutes to myRouteDefinitions

Definition at line 178 of file RONet.h.

References NamedObjectCont< T >::get(), and RONet::myRoutes.

Referenced by RORDLoader_SUMOBase::closeVehicle().

                                                                 {
        return myRoutes.get(name);
    }

SUMOVTypeParameter * RONet::getVehicleTypeSecure

(

const std::string &

id

)

throw () [inherited]

Retrieves the named vehicle type.

If the named vehicle type was not added to the net before, a default vehicle type which consists of the id only is generated, added to the net and returned.

Only if the name is "", 0 is returned.

Parameters:

[in]

id

The id of the vehicle type to return

Returns:

The named vehicle type

Todo:

Check whether a const pointer may be returned

Definition at line 130 of file RONet.cpp.

References RONet::addVehicleType(), NamedObjectCont< T >::get(), SUMOVTypeParameter::id, RONet::myVehicleTypes, and SUMOVTypeParameter::onlyReferenced.

Referenced by RORDLoader_SUMOBase::closeVehicle(), RORDLoader_TripDefs::myEndElement(), and RORDGenerator_ODAmounts::myEndFlowAmountDef().

                                                       {
    // check whether the type was already known
    SUMOVTypeParameter *type = myVehicleTypes.get(id);
    if (type!=0) {
        return type;
    }
    if (id=="") {
        // ok, no vehicle type was given within the user input
        //  return the default type
        return 0;
    }
    // Assume, the user will define the type somewhere else
    //  return a type which contains the id only
    type = new SUMOVTypeParameter();
    type->id = id;
    type->onlyReferenced = true;
    addVehicleType(type);
    return type;
}

bool RODFNet::hasApproached

(

ROEdge *

edge

)

const [protected]

Definition at line 704 of file RODFNet.cpp.

References myApproachedEdges.

Referenced by computeRoutesFor(), and isDestination().

                                         {
    return
        myApproachedEdges.find(edge)!=myApproachedEdges.end()
        &&
        myApproachedEdges.find(edge)->second.size()!=0;
}

bool RODFNet::hasApproaching

(

ROEdge *

edge

)

const [protected]

Definition at line 695 of file RODFNet.cpp.

References myApproachingEdges.

Referenced by isSource().

                                          {
    return
        myApproachingEdges.find(edge)!=myApproachingEdges.end()
        &&
        myApproachingEdges.find(edge)->second.size()!=0;
}

bool RODFNet::hasDetector

(

ROEdge *

edge

)

const

Definition at line 713 of file RODFNet.cpp.

References myDetectorsOnEdges.

Referenced by RODFDetector::buildDestinationDistribution(), computeRoutesFor(), RODFDetector::computeSplitProbabilities(), isDestination(), isFalseSource(), isSource(), and revalidateFlows().

                                       {
    return
        myDetectorsOnEdges.find(edge)!=myDetectorsOnEdges.end()
        &&
        myDetectorsOnEdges.find(edge)->second.size()!=0;
}

bool RODFNet::hasInBetweenDetectorsOnly	(	ROEdge *	edge,
		const RODFDetectorCon &	detectors
	)			const [protected]

Definition at line 159 of file RODFNet.cpp.

References BETWEEN_DETECTOR, RODFDetectorCon::getDetector(), RODFDetector::getType(), and myDetectorsOnEdges.

Referenced by computeRoutesFor().

                                                                           {
    assert(myDetectorsOnEdges.find(edge)!=myDetectorsOnEdges.end());
    const std::vector<std::string> &detIDs = myDetectorsOnEdges.find(edge)->second;
    std::vector<std::string>::const_iterator i;
    for (i=detIDs.begin(); i!=detIDs.end(); ++i) {
        const RODFDetector &det = detectors.getDetector(*i);
        if (det.getType()!=BETWEEN_DETECTOR) {
            return false;
        }
    }
    return true;
}

bool RONet::hasRestrictions

(

)

const [inherited]

Definition at line 345 of file RONet.cpp.

References RONet::myHaveRestrictions.

Referenced by computeRoutes().

                             {
    return myHaveRestrictions;
}

bool RODFNet::hasSourceDetector	(	ROEdge *	edge,
		const RODFDetectorCon &	detectors
	)			const [protected]

Definition at line 175 of file RODFNet.cpp.

References RODFDetectorCon::getDetector(), RODFDetector::getType(), myDetectorsOnEdges, and SOURCE_DETECTOR.

Referenced by computeRoutesFor().

                                                                   {
    assert(myDetectorsOnEdges.find(edge)!=myDetectorsOnEdges.end());
    const std::vector<std::string> &detIDs = myDetectorsOnEdges.find(edge)->second;
    std::vector<std::string>::const_iterator i;
    for (i=detIDs.begin(); i!=detIDs.end(); ++i) {
        const RODFDetector &det = detectors.getDetector(*i);
        if (det.getType()==SOURCE_DETECTOR) {
            return true;
        }
    }
    return false;
}

bool RODFNet::isDestination	(	const RODFDetector &	det,
		ROEdge *	edge,
		std::vector< ROEdge * > &	seen,
		const RODFDetectorCon &	detectors
	)			const [protected]

Definition at line 861 of file RODFNet.cpp.

References getAbsPos(), RODFDetectorCon::getDetector(), getDetectorEdge(), RODFDetector::getID(), ROEdge::getSpeed(), MsgHandler::getWarningInstance(), hasApproached(), hasDetector(), MsgHandler::inform(), isDestination(), myAmInHighwayMode, myApproachedEdges, myDetectorEdges, and myDetectorsOnEdges.

                                                               {
    if (seen.size()==1000) { // !!!
        MsgHandler::getWarningInstance()->inform("Quitting checking for being a destination for detector '" + det.getID() + "' due to seen edge limit.");
        return false;
    }
    if (edge==getDetectorEdge(det)) {
        // maybe there is another detector at the same edge
        //  get the list of this/these detector(s)
        const std::vector<std::string> &detsOnEdge = myDetectorsOnEdges.find(edge)->second;
        for (std::vector<std::string>::const_iterator i=detsOnEdge.begin(); i!=detsOnEdge.end(); ++i) {
            if ((*i)==det.getID()) {
                continue;
            }
            const RODFDetector &sec = detectors.getDetector(*i);
            if (getAbsPos(sec)>getAbsPos(det)) {
                // ok, there is another detector on the same edge and it is
                //  after this one -> no destination
                return false;
            }
        }
    }
    if (!hasApproached(edge)) {
        if (edge!=getDetectorEdge(det)) {
            if (hasDetector(edge)) {
                return false;
            }
        }
        return true;
    }
    if (edge!=getDetectorEdge(det)) {
        // ok, we are at one of the edges coming behind
        if (myAmInHighwayMode) {
            if (edge->getSpeed()>=19.4) {
                if (hasDetector(edge)) {
                    // we are still on the highway and there is another detector
                    return false;
                }
            }
        }
    }

    if (myAmInHighwayMode) {
        if (edge->getSpeed()<19.4&&edge!=getDetectorEdge(det)) {
            if (hasDetector(edge)) {
                return true;
            }
            if (myApproachedEdges.find(edge)->second.size()>1) {
                return true;
            }

        }
    }

    if (myDetectorsOnEdges.find(edge)!=myDetectorsOnEdges.end()
            &&
            myDetectorEdges.find(det.getID())->second!=edge) {
        return false;
    }
    const std::vector<ROEdge*> &appr  = myApproachedEdges.find(edge)->second;
    bool isall = true;
    size_t no = 0;
    seen.push_back(edge);
    for (size_t i=0; i<appr.size()&&isall; i++) {
        bool had = std::find(seen.begin(), seen.end(), appr[i])!=seen.end();
        if (!had) {
            if (!isDestination(det, appr[i], seen, detectors)) {
                no++;
                isall = false;
            }
        }
    }
    return isall;
}

bool RODFNet::isDestination	(	const RODFDetector &	det,
		const RODFDetectorCon &	detectors
	)			const [protected]

Definition at line 751 of file RODFNet.cpp.

References getDetectorEdge().

Referenced by computeTypes(), and isDestination().

                                                                                      {
    std::vector<ROEdge*> seen;
    return isDestination(det, getDetectorEdge(det), seen, detectors);
}

bool RODFNet::isFalseSource	(	const RODFDetector &	det,
		ROEdge *	edge,
		std::vector< ROEdge * > &	seen,
		const RODFDetectorCon &	detectors
	)			const [protected]

Definition at line 937 of file RODFNet.cpp.

References BETWEEN_DETECTOR, RODFDetectorCon::getDetector(), getDetectorEdge(), RODFDetector::getID(), ROEdge::getSpeed(), RODFDetector::getType(), MsgHandler::getWarningInstance(), hasDetector(), MsgHandler::inform(), isFalseSource(), myAmInHighwayMode, myApproachedEdges, myDetectorsOnEdges, SINK_DETECTOR, and SOURCE_DETECTOR.

                                                               {
    if (seen.size()==1000) { // !!!
        MsgHandler::getWarningInstance()->inform("Quitting checking for being a false source for detector '" + det.getID() + "' due to seen edge limit.");
        return false;
    }
    seen.push_back(edge);
    if (edge!=getDetectorEdge(det)) {
        // ok, we are at one of the edges coming behind
        if (hasDetector(edge)) {
            const std::vector<std::string> &dets = myDetectorsOnEdges.find(edge)->second;
            for (std::vector<std::string>::const_iterator i=dets.begin(); i!=dets.end(); ++i) {
                if (detectors.getDetector(*i).getType()==SINK_DETECTOR) {
                    return false;
                }
                if (detectors.getDetector(*i).getType()==BETWEEN_DETECTOR) {
                    return false;
                }
                if (detectors.getDetector(*i).getType()==SOURCE_DETECTOR) {
                    return true;
                }
            }
        } else {
            if (myAmInHighwayMode&&edge->getSpeed()<19.) {
                return false;
            }
        }
    }

    if (myApproachedEdges.find(edge)==myApproachedEdges.end()) {
        return false;
    }

    const std::vector<ROEdge*> &appr  = myApproachedEdges.find(edge)->second;
    bool isall = false;
    for (size_t i=0; i<appr.size()&&!isall; i++) {
        //printf("checking %s->\n", appr[i].c_str());
        bool had = std::find(seen.begin(), seen.end(), appr[i])!=seen.end();
        if (!had) {
            if (isFalseSource(det, appr[i], seen, detectors)) {
                isall = true;
            }
        }
    }
    return isall;
}

bool RODFNet::isFalseSource	(	const RODFDetector &	det,
		const RODFDetectorCon &	detectors
	)			const [protected]

Definition at line 744 of file RODFNet.cpp.

References getDetectorEdge().

Referenced by computeTypes(), and isFalseSource().

                                                                                      {
    std::vector<ROEdge*> seen;
    return
        isFalseSource(det, getDetectorEdge(det), seen, detectors);
}

bool RODFNet::isSource	(	const RODFDetector &	det,
		ROEdge *	edge,
		std::vector< ROEdge * > &	seen,
		const RODFDetectorCon &	detectors,
		bool	strict
	)			const [protected]

Definition at line 758 of file RODFNet.cpp.

References getAbsPos(), RODFDetectorCon::getDetector(), getDetectorEdge(), RODFDetector::getID(), ROEdge::getSpeed(), MsgHandler::getWarningInstance(), hasApproaching(), hasDetector(), MsgHandler::inform(), isSource(), myAmInHighwayMode, myApproachingEdges, myDetectorEdges, and myDetectorsOnEdges.

                                     {
    if (seen.size()==1000) { // !!!
        MsgHandler::getWarningInstance()->inform("Quitting checking for being a source for detector '" + det.getID() + "' due to seen edge limit.");
        return false;
    }
    if (edge==getDetectorEdge(det)) {
        // maybe there is another detector at the same edge
        //  get the list of this/these detector(s)
        const std::vector<std::string> &detsOnEdge = myDetectorsOnEdges.find(edge)->second;
        for (std::vector<std::string>::const_iterator i=detsOnEdge.begin(); i!=detsOnEdge.end(); ++i) {
            if ((*i)==det.getID()) {
                continue;
            }
            const RODFDetector &sec = detectors.getDetector(*i);
            if (getAbsPos(sec)<getAbsPos(det)) {
                // ok, there is another detector on the same edge and it is
                //  before this one -> no source
                return false;
            }
        }
    }
    // it's a source if no edges are approaching the edge
    if (!hasApproaching(edge)) {
        if (edge!=getDetectorEdge(det)) {
            if (hasDetector(edge)) {
                return false;
            }
        }
        return true;
    }
    if (edge!=getDetectorEdge(det)) {
        // ok, we are at one of the edges in front
        if (myAmInHighwayMode) {
            if (edge->getSpeed()>=19.4) {
                if (hasDetector(edge)) {
                    // we are still on the highway and there is another detector
                    return false;
                }
                // the next is a hack for the A100 scenario...
                //  We have to look into further edges herein edges
                const std::vector<ROEdge*> &appr = myApproachingEdges.find(edge)->second;
                size_t noOk = 0;
                size_t noFalse = 0;
                size_t noSkipped = 0;
                for (size_t i=0; i<appr.size(); i++) {
                    if (!hasDetector(appr[i])) {
                        noOk++;
                    } else {
                        noFalse++;
                    }
                }
                if ((noFalse+noSkipped)==appr.size()) {
                    return false;
                }
            }
        }
    }

    if (myAmInHighwayMode) {
        if (edge->getSpeed()<19.4&&edge!=getDetectorEdge(det)) {
            // we have left the highway already
            //  -> the detector will be a highway source
            if (!hasDetector(edge)) {
                return true;
            }
        }
    }
    if (myDetectorsOnEdges.find(edge)!=myDetectorsOnEdges.end()
            &&
            myDetectorEdges.find(det.getID())->second!=edge) {
        return false;
    }

    // let's check the edges in front
    const std::vector<ROEdge*> &appr = myApproachingEdges.find(edge)->second;
    size_t noOk = 0;
    size_t noFalse = 0;
    size_t noSkipped = 0;
    seen.push_back(edge);
    for (size_t i=0; i<appr.size(); i++) {
        bool had = std::find(seen.begin(), seen.end(), appr[i])!=seen.end();
        if (!had) {
            if (isSource(det, appr[i], seen, detectors, strict)) {
                noOk++;
            } else {
                noFalse++;
            }
        } else {
            noSkipped++;
        }
    }
    if (!strict) {
        return (noFalse+noSkipped)!=appr.size();
    } else {
        return (noOk+noSkipped)==appr.size();
    }
}

bool RODFNet::isSource	(	const RODFDetector &	det,
		const RODFDetectorCon &	detectors,
		bool	strict
	)			const [protected]

Definition at line 736 of file RODFNet.cpp.

References getDetectorEdge().

Referenced by computeTypes(), and isSource().

                                     {
    std::vector<ROEdge*> seen;
    return
        isSource(det, getDetectorEdge(det), seen, detectors, strict);
}

void RODFNet::mesoJoin	(	RODFDetectorCon &	detectors,
		RODFDetectorFlows &	flows
	)

Definition at line 1099 of file RODFNet.cpp.

References buildDetectorEdgeDependencies(), RODFDetectorCon::getDetector(), RODFDetector::getPos(), RODFDetectorCon::mesoJoin(), RODFDetectorFlows::mesoJoin(), myDetectorsOnEdges, and SUMOReal.

                                                                      {
    buildDetectorEdgeDependencies(detectors);
    std::map<ROEdge*, std::vector<std::string> >::iterator i;
    for (i=myDetectorsOnEdges.begin(); i!=myDetectorsOnEdges.end(); ++i) {
        ROEdge *into = (*i).first;
        const std::vector<std::string> &dets = (*i).second;
        std::map<SUMOReal, std::vector<std::string> > cliques;
        // compute detector cliques
        for (std::vector<std::string>::const_iterator j=dets.begin(); j!=dets.end(); ++j) {
            const RODFDetector &det = detectors.getDetector(*j);
            bool found = false;
            for (std::map<SUMOReal, std::vector<std::string> >::iterator k=cliques.begin(); !found&&k!=cliques.end(); ++k) {
                if (fabs((*k).first-det.getPos())<10.) {
                    (*k).second.push_back(*j);
                    found = true;
                }
            }
            if (!found) {
                cliques[det.getPos()] = std::vector<std::string>();
                cliques[det.getPos()].push_back(*j);
            }
        }
        // join detector cliques
        for (std::map<SUMOReal, std::vector<std::string> >::iterator m=cliques.begin(); m!=cliques.end(); ++m) {
            std::vector<std::string> clique = (*m).second;
            // do not join if only one
            if (clique.size()==1) {
                continue;
            }
            std::string nid;
            for (std::vector<std::string>::iterator n=clique.begin(); n!=clique.end(); ++n) {
                std::cout << *n << " ";
                if (n!=clique.begin()) {
                    nid = nid + "_";
                }
                nid = nid + *n;
            }
            std::cout << ":" << nid << std::endl;
            flows.mesoJoin(nid, (*m).second);
            detectors.mesoJoin(nid, (*m).second);
        }
    }
}

void RONet::openOutput	(	const std::string &	filename,
		bool	useAlternatives
	)			throw (IOError) [inherited]

Opens the output for computed routes.

If the second parameter is true, a second file for route alternatives will be opened. The route alternatives files is simply the given name with ".alt" appended (before the ".xml"-suffix). If one of the file outputs can not be build, an IOError is thrown

Parameters:

[in]	filename	The (base) name of the file(s) to create
[in]	useAlternatives	Whether a file for writing alternatives shall be created

Definition at line 100 of file RONet.cpp.

References OutputDevice::getDevice(), RONet::myRouteAlternativesOutput, RONet::myRoutesOutput, and OutputDevice::writeXMLHeader().

Referenced by computeRoutes().

                                                                                {
    myRoutesOutput = &OutputDevice::getDevice(filename);
    myRoutesOutput->writeXMLHeader("routes");
    if (useAlternatives) {
        size_t len = filename.length();
        if (len > 4 && filename.substr(len - 4) == ".xml") {
            myRouteAlternativesOutput = &OutputDevice::getDevice(filename.substr(0, len-4)+".alt.xml");
        } else {
            myRouteAlternativesOutput = &OutputDevice::getDevice(filename+".alt");
        }
        myRouteAlternativesOutput->writeXMLHeader("route-alternatives");
    }
}

void RODFNet::removeEmptyDetectors	(	RODFDetectorCon &	detectors,
		RODFDetectorFlows &	flows,
		SUMOTime	startTime,
		SUMOTime	endTime,
		SUMOTime	stepOffset
	)

Definition at line 640 of file RODFNet.cpp.

References RODFDetectorCon::getDetectors(), MsgHandler::getMessageInstance(), MsgHandler::inform(), RODFDetectorFlows::knows(), RODFDetectorCon::removeDetector(), and RODFDetectorFlows::removeFlow().

Referenced by startComputation().

                                                       {
    const std::vector<RODFDetector*> &dets = detectors.getDetectors();
    for (std::vector<RODFDetector*>::const_iterator i=dets.begin(); i!=dets.end();) {
        bool remove = true;
        // check whether there is at least one entry with a flow larger than zero
        if (flows.knows((*i)->getID())) {
            remove = false;
        }
        if (remove) {
            MsgHandler::getMessageInstance()->inform("Removed detector '" + (*i)->getID() + "' because no flows for him exist.");
            flows.removeFlow((*i)->getID());
            detectors.removeDetector((*i)->getID());
            i = dets.begin();
        } else {
            i++;
        }
    }
}

void RODFNet::reportEmptyDetectors	(	RODFDetectorCon &	detectors,
		RODFDetectorFlows &	flows
	)

Definition at line 665 of file RODFNet.cpp.

References RODFDetectorCon::getDetectors(), MsgHandler::getMessageInstance(), MsgHandler::inform(), and RODFDetectorFlows::knows().

Referenced by startComputation().

                                                        {
    const std::vector<RODFDetector*> &dets = detectors.getDetectors();
    for (std::vector<RODFDetector*>::const_iterator i=dets.begin(); i!=dets.end(); ++i) {
        bool remove = true;
        // check whether there is at least one entry with a flow larger than zero
        if (flows.knows((*i)->getID())) {
            remove = false;
        }
        if (remove) {
            MsgHandler::getMessageInstance()->inform("Detector '" + (*i)->getID() + "' has no flow.");
        }
    }
}

void RODFNet::revalidateFlows	(	const RODFDetector *	detector,
		RODFDetectorFlows &	flows,
		SUMOTime	startTime,
		SUMOTime	endTime,
		SUMOTime	stepOffset
	)			[protected]

Definition at line 479 of file RODFNet.cpp.

References RODFNet::IterationEdge::depth, RODFNet::IterationEdge::edge, getDetectorEdge(), RODFDetectorFlows::getFlowDefs(), RODFDetector::getID(), hasDetector(), RODFDetectorFlows::knows(), myApproachedEdges, myApproachingEdges, FlowDef::qLKW, FlowDef::qPKW, RODFDetectorFlows::setFlows(), SUMOReal, FlowDef::vLKW, FlowDef::vPKW, and WRITE_WARNING.

                                              {
    {
        if (flows.knows(detector->getID())) {
            const std::vector<FlowDef> &detFlows = flows.getFlowDefs(detector->getID());
            for (std::vector<FlowDef>::const_iterator j=detFlows.begin(); j!=detFlows.end(); ++j) {
                if ((*j).qPKW>0||(*j).qLKW>0) {
                    return;
                }
            }
        }
    }
    // ok, there is no information for the whole time;
    //  lets find preceding detectors and rebuild the flows if possible
    WRITE_WARNING("Detector '" + detector->getID() + "' has no flows.\n Trying to rebuild.");
    // go back and collect flows
    std::vector<ROEdge*> previous;
    {
        std::vector<IterationEdge> missing;
        IterationEdge ie;
        ie.depth = 0;
        ie.edge = getDetectorEdge(*detector);
        missing.push_back(ie);
        bool maxDepthReached = false;
        while (!missing.empty()&&!maxDepthReached) {
            IterationEdge last = missing.back();
            missing.pop_back();
            std::vector<ROEdge*> approaching = myApproachingEdges[last.edge];
            for (std::vector<ROEdge*>::const_iterator j=approaching.begin(); j!=approaching.end(); ++j) {
                if (hasDetector(*j)) {
                    previous.push_back(*j);
                } else {
                    ie.depth = last.depth + 1;
                    ie.edge = *j;
                    missing.push_back(ie);
                    if (ie.depth>5) {
                        maxDepthReached = true;
                    }
                }
            }
        }
        if (maxDepthReached) {
            WRITE_WARNING(" Could not build list of previous flows.");
        }
    }
    // Edges with previous detectors are now in "previous";
    //  compute following
    std::vector<ROEdge*> latter;
    {
        std::vector<IterationEdge> missing;
        for (std::vector<ROEdge*>::const_iterator k=previous.begin(); k!=previous.end(); ++k) {
            IterationEdge ie;
            ie.depth = 0;
            ie.edge = *k;
            missing.push_back(ie);
        }
        bool maxDepthReached = false;
        while (!missing.empty()&&!maxDepthReached) {
            IterationEdge last = missing.back();
            missing.pop_back();
            std::vector<ROEdge*> approached = myApproachedEdges[last.edge];
            for (std::vector<ROEdge*>::const_iterator j=approached.begin(); j!=approached.end(); ++j) {
                if (*j==getDetectorEdge(*detector)) {
                    continue;
                }
                if (hasDetector(*j)) {
                    latter.push_back(*j);
                } else {
                    IterationEdge ie;
                    ie.depth = last.depth + 1;
                    ie.edge = *j;
                    missing.push_back(ie);
                    if (ie.depth>5) {
                        maxDepthReached = true;
                    }
                }
            }
        }
        if (maxDepthReached) {
            WRITE_WARNING(" Could not build list of latter flows.");
            return;
        }
    }
    // Edges with latter detectors are now in "latter";

    // lets not validate them by now - surely this should be done
    // for each time step: collect incoming flows; collect outgoing;
    std::vector<FlowDef> mflows;
    for (SUMOTime t=startTime; t<endTime; t+=stepOffset) {
        FlowDef inFlow;
        inFlow.qLKW = 0;
        inFlow.qPKW = 0;
        inFlow.vLKW = 0;
        inFlow.vPKW = 0;
        // collect incoming
        {
            // !! time difference is missing
            for (std::vector<ROEdge*>::iterator i=previous.begin(); i!=previous.end(); ++i) {
                const std::vector<FlowDef> &flows = static_cast<const RODFEdge*>(*i)->getFlows();
                if (flows.size()!=0) {
                    const FlowDef &srcFD = flows[(int)(t/stepOffset) - startTime];
                    inFlow.qLKW += srcFD.qLKW;
                    inFlow.qPKW += srcFD.qPKW;
                    inFlow.vLKW += srcFD.vLKW;
                    inFlow.vPKW += srcFD.vPKW;
                }
            }
        }
        inFlow.vLKW /= (SUMOReal) previous.size();
        inFlow.vPKW /= (SUMOReal) previous.size();
        // collect outgoing
        FlowDef outFlow;
        outFlow.qLKW = 0;
        outFlow.qPKW = 0;
        outFlow.vLKW = 0;
        outFlow.vPKW = 0;
        {
            // !! time difference is missing
            for (std::vector<ROEdge*>::iterator i=latter.begin(); i!=latter.end(); ++i) {
                const std::vector<FlowDef> &flows = static_cast<const RODFEdge*>(*i)->getFlows();
                if (flows.size()!=0) {
                    const FlowDef &srcFD = flows[(int)(t/stepOffset) - startTime];
                    outFlow.qLKW += srcFD.qLKW;
                    outFlow.qPKW += srcFD.qPKW;
                    outFlow.vLKW += srcFD.vLKW;
                    outFlow.vPKW += srcFD.vPKW;
                }
            }
        }
        outFlow.vLKW /= (SUMOReal) latter.size();
        outFlow.vPKW /= (SUMOReal) latter.size();
        //
        FlowDef mFlow;
        mFlow.qLKW = inFlow.qLKW - outFlow.qLKW;
        mFlow.qPKW = inFlow.qPKW - outFlow.qPKW;
        mFlow.vLKW = (inFlow.vLKW + outFlow.vLKW) / (SUMOReal) 2.;
        mFlow.vPKW = (inFlow.vPKW + outFlow.vPKW) / (SUMOReal) 2.;
        mflows.push_back(mFlow);
    }
    static_cast<RODFEdge*>(getDetectorEdge(*detector))->setFlows(mflows);
    flows.setFlows(detector->getID(), mflows);
}

void RODFNet::revalidateFlows	(	const RODFDetectorCon &	detectors,
		RODFDetectorFlows &	flows,
		SUMOTime	startTime,
		SUMOTime	endTime,
		SUMOTime	stepOffset
	)

Definition at line 626 of file RODFNet.cpp.

References RODFDetectorCon::getDetectors().

Referenced by startComputation().

                                              {
    const std::vector<RODFDetector*> &dets = detectors.getDetectors();
    for (std::vector<RODFDetector*>::const_iterator i=dets.begin(); i!=dets.end(); ++i) {
        // check whether there is at least one entry with a flow larger than zero
        revalidateFlows(*i, flows, startTime, endTime, stepOffset);
    }
}

SUMOTime RONet::saveAndRemoveRoutesUntil	(	OptionsCont &	options,
		SUMOAbstractRouter< ROEdge, ROVehicle > &	router,
		SUMOTime	time
	)			[inherited]

Computes routes described by their definitions and saves them.

As long a vehicle with a departure time not larger than the given exists, its route is computed and it is written and removed from the internal container.

Parameters:

[in]	options	The options used during this process
[in]	router	The router to use for routes computation
[in]	options	The time until which route definitions shall be processed

Returns:

The last seen departure time>=time

Definition at line 214 of file RONet.cpp.

References RONet::computeRoute(), ROVehicleCont::erase(), OptionsCont::getBool(), ROVehicle::getDepartureTime(), ROVehicle::getID(), OptionsCont::getInt(), ROVehicleCont::getTopVehicle(), RONet::myDiscardedRouteNo, RONet::myReadRouteNo, RONet::myRouteAlternativesOutput, RONet::myRoutesOutput, RONet::myVehicles, RONet::myWrittenRouteNo, ROVehicle::saveAllAsXML(), NamedObjectCont< T >::size(), toString(), and WRITE_MESSAGE.

Referenced by ROLoader::makeSingleStep(), and ROLoader::processAllRoutes().

                                               {
    SUMOTime lastTime = -1;
    // write all vehicles (and additional structures)
    while (myVehicles.size()!=0) {
        // get the next vehicle
        const ROVehicle * const veh = myVehicles.getTopVehicle();
        SUMOTime currentTime = veh->getDepartureTime();
        // check whether it shall not yet be computed
        if (currentTime>time) {
            lastTime = currentTime;
            break;
        }
        // check whether to print the output
        if (lastTime!=currentTime&&lastTime!=-1) {
            // report writing progress
            if (options.getInt("stats-period")>=0 && ((int) currentTime%options.getInt("stats-period"))==0) {
                WRITE_MESSAGE("Read: " + toString(myReadRouteNo) + ",  Discarded: " + toString(myDiscardedRouteNo) + ",  Written: " + toString(myWrittenRouteNo));
            }
        }
        lastTime = currentTime;

        // ok, compute the route (try it)
        if (computeRoute(options, router, veh)) {
            // write the route
            veh->saveAllAsXML(router, *myRoutesOutput, myRouteAlternativesOutput, options.getBool("exit-times"));
            myWrittenRouteNo++;
            // remove the route if it is not longer used
            /*
            if (!myRoutes.erase(route->getID())) {
                MsgHandler::getWarningInstance()->inform("Could not remove " + route->getID());
            }
            */
        } else {
            myDiscardedRouteNo++;
        }
        // and the vehicle
        myVehicles.erase(veh->getID());
    }
    return lastTime;
}

void RONet::setRestrictionFound

(

)

[inherited]

Definition at line 351 of file RONet.cpp.

References RONet::myHaveRestrictions.

Referenced by RONetHandler::parseLane().

                           {
    myHaveRestrictions = true;
}

---

Field Documentation

bool RODFNet::myAmInHighwayMode [private]

Definition at line 161 of file RODFNet.h.

Referenced by computeRoutesFor(), isDestination(), isFalseSource(), and isSource().

std::map<ROEdge*, std::vector<ROEdge*> > RODFNet::myApproachedEdges [private]

Map of edge name->list of names of edges approached by this edge.

Definition at line 156 of file RODFNet.h.

Referenced by buildApproachList(), computeRoutesFor(), hasApproached(), isDestination(), isFalseSource(), and revalidateFlows().

std::map<ROEdge*, std::vector<ROEdge*> > RODFNet::myApproachingEdges [private]

Map of edge name->list of names of this edge approaching edges.

Definition at line 153 of file RODFNet.h.

Referenced by buildApproachList(), hasApproaching(), isSource(), and revalidateFlows().

std::vector<ROEdge*> RONet::myDestinationEdges [mutable, protected, inherited]

List of destination edges.

Definition at line 320 of file RONet.h.

Referenced by RONet::checkSourceAndDestinations(), and RONet::getRandomDestination().

std::map<std::string, ROEdge*> RODFNet::myDetectorEdges [mutable, private]

Definition at line 159 of file RODFNet.h.

Referenced by buildDetectorDependencies(), buildDetectorEdgeDependencies(), isDestination(), and isSource().

std::map<ROEdge*, std::vector<std::string> > RODFNet::myDetectorsOnEdges [mutable, private]

Definition at line 158 of file RODFNet.h.

Referenced by buildDetectorDependencies(), buildDetectorEdgeDependencies(), buildEdgeFlowMap(), buildRoutes(), getDetectorList(), hasDetector(), hasInBetweenDetectorsOnly(), hasSourceDetector(), isDestination(), isFalseSource(), isSource(), and mesoJoin().

std::vector<std::string> RODFNet::myDisallowedEdges [private]

List of ids of edges that shall not be used.

Definition at line 165 of file RODFNet.h.

Referenced by buildApproachList().

unsigned int RONet::myDiscardedRouteNo [protected, inherited]

The number of discarded routes.

Definition at line 332 of file RONet.h.

Referenced by RONet::saveAndRemoveRoutesUntil().

NamedObjectCont<ROEdge*> RONet::myEdges [protected, inherited]

Known edges.

Definition at line 305 of file RONet.h.

Referenced by RONet::addEdge(), RONet::checkSourceAndDestinations(), RONet::getEdge(), RONet::getEdgeMap(), RONet::getEdgeNo(), and RONet::~RONet().

bool RONet::myHaveRestrictions [protected, inherited]

Whether the network contains edges which not all vehicles may pass.

Definition at line 338 of file RONet.h.

Referenced by RONet::hasRestrictions(), and RONet::setRestrictionFound().

size_t RODFNet::myInBetweenNumber [mutable, private]

Definition at line 162 of file RODFNet.h.

Referenced by computeTypes().

size_t RODFNet::myInvalidNumber [mutable, private]

Definition at line 162 of file RODFNet.h.

Referenced by computeTypes().

bool RODFNet::myKeepTurnarounds [private]

Definition at line 168 of file RODFNet.h.

Referenced by buildApproachList().

NamedObjectCont<RONode*> RONet::myNodes [protected, inherited]

Known nodes.

Definition at line 302 of file RONet.h.

Referenced by RONet::addNode(), RONet::getNode(), and RONet::~RONet().

unsigned int RONet::myReadRouteNo [protected, inherited]

The number of read routes.

Definition at line 329 of file RONet.h.

Referenced by RONet::addVehicle(), and RONet::saveAndRemoveRoutesUntil().

OutputDevice* RONet::myRouteAlternativesOutput [protected, inherited]

The file to write the computed route alternatives into.

Definition at line 326 of file RONet.h.

Referenced by RONet::closeOutput(), RONet::openOutput(), and RONet::saveAndRemoveRoutesUntil().

NamedObjectCont<RORouteDef*> RONet::myRoutes [protected, inherited]

Known routes.

Definition at line 311 of file RONet.h.

Referenced by RONet::addRouteDef(), RONet::getRouteDef(), and RONet::~RONet().

OutputDevice* RONet::myRoutesOutput [protected, inherited]

The file to write the computed routes into.

Definition at line 323 of file RONet.h.

Referenced by RONet::closeOutput(), RONet::openOutput(), and RONet::saveAndRemoveRoutesUntil().

size_t RODFNet::mySinkNumber [mutable, private]

Definition at line 162 of file RODFNet.h.

Referenced by computeTypes().

std::vector<ROEdge*> RONet::mySourceEdges [mutable, protected, inherited]

List of source edges.

Definition at line 317 of file RONet.h.

Referenced by RONet::checkSourceAndDestinations(), and RONet::getRandomSource().

size_t RODFNet::mySourceNumber [mutable, private]

Definition at line 162 of file RODFNet.h.

Referenced by computeTypes().

ROVehicleCont RONet::myVehicles [protected, inherited]

Known vehicles.

Definition at line 314 of file RONet.h.

Referenced by RONet::addVehicle(), RONet::furtherStored(), RONet::saveAndRemoveRoutesUntil(), and RONet::~RONet().

NamedObjectCont<SUMOVTypeParameter*> RONet::myVehicleTypes [protected, inherited]

Known vehicle types.

Definition at line 308 of file RONet.h.

Referenced by RONet::addVehicleType(), RONet::getVehicleTypeSecure(), and RONet::~RONet().

std::set<std::string> RONet::myVehIDs [protected, inherited]

Known vehicle ids.

Definition at line 299 of file RONet.h.

Referenced by RONet::addVehicle().

unsigned int RONet::myWrittenRouteNo [protected, inherited]

The number of written routes.

Definition at line 335 of file RONet.h.

Referenced by RONet::saveAndRemoveRoutesUntil().

---

The documentation for this class was generated from the following files:

• RODFNet.h
• RODFNet.cpp