traci._simulation

  1# -*- coding: utf-8 -*-
  2# Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
  3# Copyright (C) 2011-2026 German Aerospace Center (DLR) and others.
  4# This program and the accompanying materials are made available under the
  5# terms of the Eclipse Public License 2.0 which is available at
  6# https://www.eclipse.org/legal/epl-2.0/
  7# This Source Code may also be made available under the following Secondary
  8# Licenses when the conditions for such availability set forth in the Eclipse
  9# Public License 2.0 are satisfied: GNU General Public License, version 2
 10# or later which is available at
 11# https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
 12# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
 13
 14# @file    _simulation.py
 15# @author  Daniel Krajzewicz
 16# @author  Jakob Erdmann
 17# @author  Michael Behrisch
 18# @date    2011-03-15
 19
 20from __future__ import absolute_import
 21import warnings
 22from . import constants as tc
 23from .domain import Domain
 24from .exceptions import FatalTraCIError, deprecated
 25
 26
 27class Stage(object):
 28
 29    def __init__(self,
 30                 type=tc.INVALID_INT_VALUE,
 31                 vType="",
 32                 line="",
 33                 destStop="",
 34                 edges=[],
 35                 travelTime=tc.INVALID_DOUBLE_VALUE,
 36                 cost=tc.INVALID_DOUBLE_VALUE,
 37                 length=tc.INVALID_DOUBLE_VALUE,
 38                 intended="",
 39                 depart=tc.INVALID_DOUBLE_VALUE,
 40                 departPos=tc.INVALID_DOUBLE_VALUE,
 41                 arrivalPos=tc.INVALID_DOUBLE_VALUE,
 42                 description=""):
 43        self.type = type
 44        self.vType = vType
 45        self.line = line
 46        self.destStop = destStop
 47        self.edges = edges
 48        self.travelTime = travelTime
 49        self.cost = cost
 50        self.length = length
 51        self.intended = intended
 52        self.depart = depart
 53        self.departPos = departPos
 54        self.arrivalPos = arrivalPos
 55        self.description = description
 56
 57    def __attr_repr__(self, attrname, default=""):
 58        if getattr(self, attrname) == default:
 59            return ""
 60        else:
 61            val = getattr(self, attrname)
 62            if val == tc.INVALID_DOUBLE_VALUE:
 63                val = "INVALID"
 64            return "%s=%s" % (attrname, val)
 65
 66    def __repr__(self):
 67        return "Stage(%s)" % ', '.join([v for v in [
 68            self.__attr_repr__("type"),
 69            self.__attr_repr__("vType"),
 70            self.__attr_repr__("line"),
 71            self.__attr_repr__("destStop"),
 72            self.__attr_repr__("edges"),
 73            self.__attr_repr__("travelTime"),
 74            self.__attr_repr__("cost"),
 75            self.__attr_repr__("length"),
 76            self.__attr_repr__("intended"),
 77            self.__attr_repr__("depart"),
 78            self.__attr_repr__("departPos"),
 79            self.__attr_repr__("arrivalPos"),
 80            self.__attr_repr__("description"),
 81        ] if v != ""])
 82
 83    def toXML(self, firstStage=True, isPerson=True, extra=[]):
 84        """write stage as xml element.
 85        If firstStage=False, the from-attribute is omitted since sumo derives it from the prior stage.
 86        If extra is a list of (attrname, value) these will be added to the xml element
 87        """
 88        if self.type == tc.STAGE_WAITING:
 89            to = ' edge="%s" endPos="%.2f"' % (self.edges[-1], self.arrivalPos)
 90            if self.destStop:
 91                to = ' busStop="%s"' % self.destStop
 92            other = ''
 93            if self.travelTime >= 0:
 94                other += ' duration="%s"' % self.travelTime
 95            other += ''.join([' %s="%s"' % i for i in extra])
 96            return '<stop%s%s/>' % (to, other)
 97
 98        elif self.type == tc.STAGE_DRIVING:
 99            fro = ' from="%s"' % self.edges[0] if firstStage else ''
100            to = ' to="%s" arrivalPos="%.2f"' % (self.edges[-1], self.arrivalPos)
101            if self.destStop:
102                to = ' busStop="%s"' % self.destStop
103            elem = "ride" if isPerson else "transport"
104            other = ''
105            if self.line:
106                other += ' lines="%s"' % self.line
107            if self.intended:
108                other += ' intended="%s"' % self.intended
109            if self.depart != tc.INVALID_DOUBLE_VALUE:
110                other += ' depart="%s"' % self.depart
111            other += ''.join([' %s="%s"' % i for i in extra])
112            return '<%s%s%s%s/>' % (elem, fro, to, other)
113
114        elif self.type == tc.STAGE_WALKING:
115            to = ' arrivalPos="%.2f"' % self.arrivalPos
116            if self.destStop:
117                to = ' busStop="%s"' % self.destStop
118            edges = ' edges="%s"' % ' '.join(self.edges)
119            other = ''.join([' %s="%s"' % i for i in extra])
120            return '<walk%s%s%s/>' % (edges, to, other)
121
122        elif self.type == tc.STAGE_TRIP:
123            fro = ' from="%s"' % self.edges[0] if firstStage else ''
124            to = ' to="%s" arrivalPos="%.2f"' % (self.edges[-1], self.arrivalPos)
125            if self.destStop:
126                to = ' busStop="%s"' % self.destStop
127            other = ''
128            if self.vType:
129                other += ' vTypes="%s"' % self.vType
130            other += ''.join([' %s="%s"' % i for i in extra])
131            return '<personTrip%s%s%s/>' % (fro, to, other)
132
133        elif self.type == tc.STAGE_TRANSHIP:
134            fro = ' from="%s"' % self.edges[0] if firstStage else ''
135            to = ' to="%s" arrivalPos="%.2f"' % (self.edges[-1], self.arrivalPos)
136            if self.destStop:
137                to = ' busStop="%s"' % self.destStop
138            other = ''.join([' %s="%s"' % i for i in extra])
139            return '<tranship%s%s%s/>' % (fro, to, other)
140
141        else:
142            # STAGE_ACCESS and STAGE_WAITING_FOR_DEPART are never read from xml
143            # print("unwritten stage: ", self.type)
144            return ""
145
146
147def _readStage(result):
148    # compound size and type
149    assert result.read("!i")[0] == 13
150    stageType = result.readTypedInt()
151    vType = result.readTypedString()
152    line = result.readTypedString()
153    destStop = result.readTypedString()
154    edges = result.readTypedStringList()
155    travelTime = result.readTypedDouble()
156    cost = result.readTypedDouble()
157    length = result.readTypedDouble()
158    intended = result.readTypedString()
159    depart = result.readTypedDouble()
160    departPos = result.readTypedDouble()
161    arrivalPos = result.readTypedDouble()
162    description = result.readTypedString()
163    return Stage(stageType, vType, line, destStop, edges, travelTime, cost,
164                 length, intended, depart, departPos, arrivalPos, description)
165
166
167def _writeStage(stage):
168    format = "tisssldddsddds"
169    values = [13, stage.type, stage.vType, stage.line, stage.destStop, stage.edges,
170              stage.travelTime, stage.cost, stage.length, stage.intended,
171              stage.depart, stage.departPos, stage.arrivalPos, stage.description]
172    return format, values
173
174
175class Collision(object):
176
177    def __init__(self, collider, victim, colliderType, victimType,
178                 colliderSpeed, victimSpeed, collisionType, lane, pos):
179        self.collider = collider
180        self.victim = victim
181        self.colliderType = colliderType
182        self.victimType = victimType
183        self.colliderSpeed = colliderSpeed
184        self.victimSpeed = victimSpeed
185        self.type = collisionType
186        self.lane = lane
187        self.pos = pos
188
189    def __attr_repr__(self, attrname, default=""):
190        if getattr(self, attrname) == default:
191            return ""
192        else:
193            val = getattr(self, attrname)
194            if val == tc.INVALID_DOUBLE_VALUE:
195                val = "INVALID"
196            return "%s=%s" % (attrname, val)
197
198    def __repr__(self):
199        return "Collision(%s)" % ', '.join([v for v in [
200            self.__attr_repr__("collider"),
201            self.__attr_repr__("victim"),
202            self.__attr_repr__("colliderType"),
203            self.__attr_repr__("victimType"),
204            self.__attr_repr__("colliderSpeed"),
205            self.__attr_repr__("victimSpeed"),
206            self.__attr_repr__("type"),
207            self.__attr_repr__("lane"),
208            self.__attr_repr__("pos"),
209        ] if v != ""])
210
211
212def _readCollisions(result):
213    result.read("!iB")  # numCompounds, TYPE_INT
214    n = result.read("!i")[0]
215    values = []
216    for _ in range(n):
217        collider = result.readTypedString()
218        victim = result.readTypedString()
219        colliderType = result.readTypedString()
220        victimType = result.readTypedString()
221        colliderSpeed = result.readTypedDouble()
222        victimSpeed = result.readTypedDouble()
223        collisionType = result.readTypedString()
224        lane = result.readTypedString()
225        pos = result.readTypedDouble()
226        values.append(Collision(collider, victim, colliderType, victimType,
227                                colliderSpeed, victimSpeed, collisionType, lane, pos))
228
229    return tuple(values)
230
231
232_RETURN_VALUE_FUNC = {
233    tc.FIND_ROUTE: _readStage,
234    tc.VAR_COLLISIONS: _readCollisions
235}
236
237
238class SimulationDomain(Domain):
239
240    Stage = Stage
241
242    def __init__(self):
243        Domain.__init__(self, "simulation", tc.CMD_GET_SIM_VARIABLE, tc.CMD_SET_SIM_VARIABLE,
244                        tc.CMD_SUBSCRIBE_SIM_VARIABLE, tc.RESPONSE_SUBSCRIBE_SIM_VARIABLE,
245                        tc.CMD_SUBSCRIBE_SIM_CONTEXT, tc.RESPONSE_SUBSCRIBE_SIM_CONTEXT,
246                        _RETURN_VALUE_FUNC)
247
248    @staticmethod
249    def walkingStage(edges, arrivalPos, destStop="", description=""):
250        return Stage(2, "", "", destStop, edges, 0, 0, 0, "", 0, 0, arrivalPos, description)
251
252    def getTime(self):
253        """getTime() -> double
254
255        Returns the current simulation time in s.
256        """
257        return self._getUniversal(tc.VAR_TIME)
258
259    def getEndTime(self):
260        """getEndTime() -> double
261
262        Returns the configured end time of the simulation in s or -1
263        """
264        return self._getUniversal(tc.VAR_END)
265
266    def step(self, time=0.):
267        """step(double) -> None
268        Make a simulation step and simulate up to the given sim time (in seconds).
269        If the given value is 0 or absent, exactly one step is performed.
270        Values smaller than or equal to the current sim time result in no action.
271        """
272        if self._connection is None:
273            raise FatalTraCIError("Not connected.")
274        self._connection.simulationStep(time)
275
276    def executeMove(self):
277        """executeMove() -> None
278        Make "half" a simulation step.
279        """
280        if self._connection is None:
281            raise FatalTraCIError("Not connected.")
282        self._connection._sendCmd(tc.CMD_EXECUTEMOVE, None, None)
283
284    def getCurrentTime(self):
285        """getCurrentTime() -> integer
286
287        Returns the current simulation time in ms.
288        """
289        warnings.warn("getCurrentTime is deprecated, please use getTime which returns floating point seconds",
290                      stacklevel=2)
291        return self._getUniversal(tc.VAR_TIME_STEP)
292
293    def getLoadedNumber(self):
294        """getLoadedNumber() -> integer
295
296        Returns the number of vehicles which were loaded in this time step.
297        """
298        return self._getUniversal(tc.VAR_LOADED_VEHICLES_NUMBER)
299
300    def getLoadedIDList(self):
301        """getLoadedIDList() -> tuple(string)
302
303        Returns a tuple of ids of vehicles which were loaded in this time step.
304        """
305        return self._getUniversal(tc.VAR_LOADED_VEHICLES_IDS)
306
307    def getDepartedNumber(self):
308        """getDepartedNumber() -> integer
309
310        Returns the number of vehicles which departed (were inserted into the road network) in this time step.
311        """
312        return self._getUniversal(tc.VAR_DEPARTED_VEHICLES_NUMBER)
313
314    def getDepartedIDList(self):
315        """getDepartedIDList() -> tuple(string)
316
317        Returns a tuple of ids of vehicles which departed (were inserted into the road network) in this time step.
318        """
319        return self._getUniversal(tc.VAR_DEPARTED_VEHICLES_IDS)
320
321    def getArrivedNumber(self):
322        """getArrivedNumber() -> integer
323
324        Returns the number of vehicles which arrived (have reached their destination and are removed from the road
325        network) in this time step.
326        """
327        return self._getUniversal(tc.VAR_ARRIVED_VEHICLES_NUMBER)
328
329    def getArrivedIDList(self):
330        """getArrivedIDList() -> tuple(string)
331
332        Returns a tuple of ids of vehicles which arrived (have reached their destination and are removed from the road
333        network) in this time step.
334        """
335        return self._getUniversal(tc.VAR_ARRIVED_VEHICLES_IDS)
336
337    def getDepartedPersonNumber(self):
338        """getDepartedPersonNumber() -> integer
339
340        Returns the number of persons which departed (were inserted into the road network) in this time step.
341        """
342        return self._getUniversal(tc.VAR_DEPARTED_PERSONS_NUMBER)
343
344    def getDepartedPersonIDList(self):
345        """getDepartedPersonIDList() -> tuple(string)
346
347        Returns a tuple of ids of persons which departed (were inserted into the road network) in this time step.
348        """
349        return self._getUniversal(tc.VAR_DEPARTED_PERSONS_IDS)
350
351    def getArrivedPersonNumber(self):
352        """getArrivedPersonNumber() -> integer
353
354        Returns the number of persons which arrived (have reached their destination and are removed from the road
355        network) in this time step.
356        """
357        return self._getUniversal(tc.VAR_ARRIVED_PERSONS_NUMBER)
358
359    def getArrivedPersonIDList(self):
360        """getArrivedPersonIDList() -> tuple(string)
361
362        Returns a tuple of ids of persons which arrived (have reached their destination and are removed from the road
363        network) in this time step.
364        """
365        return self._getUniversal(tc.VAR_ARRIVED_PERSONS_IDS)
366
367    def getParkingStartingVehiclesNumber(self):
368        """getParkingStartingVehiclesNumber() -> integer
369
370        .
371        """
372        return self._getUniversal(tc.VAR_PARKING_STARTING_VEHICLES_NUMBER)
373
374    def getParkingStartingVehiclesIDList(self):
375        """getParkingStartingVehiclesIDList() -> tuple(string)
376
377        .
378        """
379        return self._getUniversal(tc.VAR_PARKING_STARTING_VEHICLES_IDS)
380
381    def getParkingEndingVehiclesNumber(self):
382        """getParkingEndingVehiclesNumber() -> integer
383
384        .
385        """
386        return self._getUniversal(tc.VAR_PARKING_ENDING_VEHICLES_NUMBER)
387
388    def getParkingEndingVehiclesIDList(self):
389        """getParkingEndingVehiclesIDList() -> tuple(string)
390
391        .
392        """
393        return self._getUniversal(tc.VAR_PARKING_ENDING_VEHICLES_IDS)
394
395    def getStopStartingVehiclesNumber(self):
396        """getStopStartingVehiclesNumber() -> integer
397
398        .
399        """
400        return self._getUniversal(tc.VAR_STOP_STARTING_VEHICLES_NUMBER)
401
402    def getStopStartingVehiclesIDList(self):
403        """getStopStartingVehiclesIDList() -> tuple(string)
404
405        .
406        """
407        return self._getUniversal(tc.VAR_STOP_STARTING_VEHICLES_IDS)
408
409    def getStopEndingVehiclesNumber(self):
410        """getStopEndingVehiclesNumber() -> integer
411
412        .
413        """
414        return self._getUniversal(tc.VAR_STOP_ENDING_VEHICLES_NUMBER)
415
416    def getStopEndingVehiclesIDList(self):
417        """getStopEndingVehiclesIDList() -> tuple(string)
418
419        .
420        """
421        return self._getUniversal(tc.VAR_STOP_ENDING_VEHICLES_IDS)
422
423    def getCollidingVehiclesNumber(self):
424        """getCollidingVehiclesNumber() -> integer
425        Return number of vehicles involved in a collision (typically 2 per
426        collision).
427        """
428        return self._getUniversal(tc.VAR_COLLIDING_VEHICLES_NUMBER)
429
430    def getCollidingVehiclesIDList(self):
431        """getCollidingVehiclesIDList() -> tuple(string)
432        Return Ids of vehicles involved in a collision (typically 2 per
433        collision).
434        """
435        return self._getUniversal(tc.VAR_COLLIDING_VEHICLES_IDS)
436
437    def getEmergencyStoppingVehiclesNumber(self):
438        """getEmergencyStoppingVehiclesNumber() -> integer
439        Return number of vehicles that performed an emergency stop in the last step
440        """
441        return self._getUniversal(tc.VAR_EMERGENCYSTOPPING_VEHICLES_NUMBER)
442
443    def getEmergencyStoppingVehiclesIDList(self):
444        """getEmergencyStoppingVehiclesIDList() -> tuple(string)
445        Return Ids of vehicles that peformed an emergency stop in the last step
446        """
447        return self._getUniversal(tc.VAR_EMERGENCYSTOPPING_VEHICLES_IDS)
448
449    def getMinExpectedNumber(self):
450        """getMinExpectedNumber() -> integer
451        Returns the number of all active vehicles and persons which are in the net plus the
452        ones still waiting to start. Vehicles and persons currently stopped with a
453        'trigger' are excluded from this number (if only triggered objects
454        remain, the trigger condition cannot be fulfilled and all objects remain
455        stopped without user intervention).
456        The returned number may also be smaller than
457        the actual number of vehicles still to come because of delayed
458        route file parsing. If the number is 0 however, it is
459        guaranteed that all route files have been parsed completely.
460        """
461        return self._getUniversal(tc.VAR_MIN_EXPECTED_VEHICLES)
462
463    @deprecated("busstop.getIDList")
464    def getBusStopIDList(self):
465        return self._getUniversal(tc.VAR_BUS_STOP_ID_LIST)
466
467    @deprecated("busstop.getPersonCount")
468    def getBusStopWaiting(self, stopID):
469        """getBusStopWaiting() -> integer
470        Get the total number of waiting persons at the named bus stop.
471        """
472        return self._getUniversal(tc.VAR_BUS_STOP_WAITING, stopID)
473
474    @deprecated("busstop.getPersonIDs")
475    def getBusStopWaitingIDList(self, stopID):
476        """getBusStopWaiting() -> tuple(string)
477        Get the IDs of waiting persons at the named bus stop.
478        """
479        return self._getUniversal(tc.VAR_BUS_STOP_WAITING_IDS, stopID)
480
481    def getStartingTeleportNumber(self):
482        """getStartingTeleportNumber() -> integer
483
484        Returns the number of vehicles which started to teleport in this time step.
485        """
486        return self._getUniversal(tc.VAR_TELEPORT_STARTING_VEHICLES_NUMBER)
487
488    def getStartingTeleportIDList(self):
489        """getStartingTeleportIDList() -> tuple(string)
490
491        Returns a tuple of ids of vehicles which started to teleport in this time step.
492        """
493        return self._getUniversal(tc.VAR_TELEPORT_STARTING_VEHICLES_IDS)
494
495    def getEndingTeleportNumber(self):
496        """getEndingTeleportNumber() -> integer
497
498        Returns the number of vehicles which ended to be teleported in this time step.
499        """
500        return self._getUniversal(tc.VAR_TELEPORT_ENDING_VEHICLES_NUMBER)
501
502    def getEndingTeleportIDList(self):
503        """getEndingTeleportIDList() -> tuple(string)
504
505        Returns a tuple of ids of vehicles which ended to be teleported in this time step.
506        """
507        return self._getUniversal(tc.VAR_TELEPORT_ENDING_VEHICLES_IDS)
508
509    def getCollisions(self):
510        """getCollisions() -> tuple(Collision)
511        Returns a tuple of collision objects
512        """
513        return self._getUniversal(tc.VAR_COLLISIONS)
514
515    def getPendingVehicles(self):
516        """getPendingVehicles() -> tuple(string)
517        Returns a tuple of all vehicle ids waiting for insertion (with depart delay)
518        """
519        return self._getUniversal(tc.VAR_PENDING_VEHICLES)
520
521    def getScale(self):
522        """getScale() -> double
523
524        Returns the traffic scaling factor
525        """
526        return self._getUniversal(tc.VAR_SCALE)
527
528    def getOption(self, option):
529        """getOption(string) -> string
530
531        Returns the value of the given SUMO option
532        """
533        return self._getUniversal(tc.VAR_OPTION, option)
534
535    def getDeltaT(self):
536        """getDeltaT() -> double
537        Returns the length of one simulation step in seconds
538        """
539        return self._getUniversal(tc.VAR_DELTA_T)
540
541    def getNetBoundary(self):
542        """getNetBoundary() -> ((double, double), (double, double))
543
544        The boundary box of the simulation network.
545        """
546        return self._getUniversal(tc.VAR_NET_BOUNDING_BOX)
547
548    def convert2D(self, edgeID, pos, laneIndex=0, toGeo=False):
549        posType = tc.POSITION_2D
550        if toGeo:
551            posType = tc.POSITION_LON_LAT
552        return self._getUniversal(tc.POSITION_CONVERSION, "", "trB", 2, (edgeID, pos, laneIndex), posType)
553
554    def convert3D(self, edgeID, pos, laneIndex=0, toGeo=False):
555        posType = tc.POSITION_3D
556        if toGeo:
557            posType = tc.POSITION_LON_LAT_ALT
558        return self._getUniversal(tc.POSITION_CONVERSION, "", "trB", 2, (edgeID, pos, laneIndex), posType)
559
560    def convertRoad(self, x, y, isGeo=False, vClass="ignoring"):
561        format = "toBs"
562        if isGeo:
563            format = "tgBs"
564        result = self._getCmd(tc.POSITION_CONVERSION, "", format, 3, (x, y), tc.POSITION_ROADMAP, vClass)
565        result.read("!B")
566        return result.readString(), result.readDouble(), result.read("!B")[0]
567
568    def convertGeo(self, x, y, fromGeo=False):
569        format = "toB"
570        toType = tc.POSITION_LON_LAT
571        if fromGeo:
572            format = "tgB"
573            toType = tc.POSITION_2D
574        return self._getUniversal(tc.POSITION_CONVERSION, "", format, 2, (x, y), toType)
575
576    def getDistance2D(self, x1, y1, x2, y2, isGeo=False, isDriving=False):
577        """getDistance2D(double, double, double, double, boolean, boolean) -> double
578
579        Returns the distance between the two coordinate pairs (x1,y1) and (x2,y2)
580
581        If isGeo=True, coordinates are interpreted as longitude and latitude rather
582        than cartesian coordinates in meters.
583
584        If isDriving=True, the coordinates are mapped onto the road network and the
585        length of the shortest route in the network is returned. Otherwise, the
586        straight-line distance is returned.
587        """
588        format = "tggu" if isGeo else "toou"
589        distType = tc.REQUEST_AIRDIST
590        if isDriving:
591            distType = tc.REQUEST_DRIVINGDIST
592        return self._getUniversal(tc.DISTANCE_REQUEST, "", format, 3, (x1, y1), (x2, y2), distType)
593
594    def getDistanceRoad(self, edgeID1, pos1, edgeID2, pos2, isDriving=False):
595        """getDistanceRoad(string, double, string, double, boolean) -> double
596
597        Reads two positions on the road network and an indicator whether the air or the driving distance shall be
598        computed. Returns the according distance.
599        """
600        distType = tc.REQUEST_AIRDIST
601        if isDriving:
602            distType = tc.REQUEST_DRIVINGDIST
603        return self._getUniversal(tc.DISTANCE_REQUEST, "", "trru", 3,
604                                  (edgeID1, pos1, 0), (edgeID2, pos2, 0), distType)
605
606    def findRoute(self, fromEdge, toEdge, vType="", depart=-1., routingMode=0,
607                  departPos=0., arrivalPos=tc.INVALID_DOUBLE_VALUE):
608        """findRoute(string, string, string, double, int, double, double) -> Stage
609        Computes the fastest route between the given edges for the given vehicle
610        type (defaults to DEFAULT_VEHTYPE)
611        Returns a Stage object that holds the edge list and the travel time
612        When the depart time is not set, the travel times at the current time
613        will be used. The routing mode may be ROUTING_MODE_DEFAULT (loaded or
614        default speeds) and ROUTING_MODE_AGGREGATED (averaged historical speeds)
615        """
616        return self._getUniversal(tc.FIND_ROUTE, "", "tsssdidd", 7, fromEdge, toEdge, vType, depart,
617                                  routingMode, departPos, arrivalPos)
618
619    def findIntermodalRoute(self, fromEdge, toEdge, modes="", depart=-1., routingMode=0, speed=-1.,
620                            walkFactor=-1., departPos=0., arrivalPos=tc.INVALID_DOUBLE_VALUE, departPosLat=0.,
621                            pType="", vType="", destStop=""):
622        """findIntermodalRoute(string, string, string, double, int, double,
623        double, double, double, double, string, string, string) -> tuple(Stage)
624        Computes the fastest intermoal route between the given edges for the
625        given combination of transport modes (i.e. "car public" may result in
626        driving to the train station and then riding the train).
627        Returns a tuple of Stage objects that correspond to the sequence of walks
628        and rides to reach the destination.
629        When the depart time is not set, the travel times at the current time will be used.
630        The routing mode may be ROUTING_MODE_DEFAULT (loaded or
631        default speeds) and ROUTING_MODE_AGGREGATED (averaged historical speeds)
632        pType defines the pedestrian type (for walking speed) and defaults to
633        DEFAULT_PEDTYPE.
634        walkFactor is a multiplier for the walking speed to
635        account for delays due to intersections and other traffic when
636        determining the feasibility of using a particular public transport
637        vehicle.
638        vType is an optional vehicle type to use for private car routing.
639        destStop can be used as an alternative to 'toEdge' to define the edge
640        and position of the specified public transport stop as the destination
641        """
642        answer = self._getCmd(tc.FIND_INTERMODAL_ROUTE, "", "tsssdidddddsss", 13,
643                              fromEdge, toEdge, modes, depart, routingMode, speed, walkFactor,
644                              departPos, arrivalPos, departPosLat, pType, vType, destStop)
645        answer.read("!B")                   # Type
646        result = []
647        for _ in range(answer.readInt()):
648            answer.read("!B")                   # Type
649            result.append(_readStage(answer))
650        return tuple(result)
651
652    def setScale(self, value):
653        """setScale(value) -> None
654
655        Sets the traffic scaling factor
656        """
657        self._setCmd(tc.VAR_SCALE, "", "d", value)
658
659    def clearPending(self, routeID=""):
660        self._setCmd(tc.CMD_CLEAR_PENDING_VEHICLES, "", "s", routeID)
661
662    def saveState(self, fileName):
663        self._setCmd(tc.CMD_SAVE_SIMSTATE, "", "s", fileName)
664
665    def loadState(self, fileName):
666        self._setCmd(tc.CMD_LOAD_SIMSTATE, "", "s", fileName)
667
668    def writeMessage(self, msg):
669        self._setCmd(tc.CMD_MESSAGE, "", "s", msg)
670
671    def subscribe(self, varIDs=(tc.VAR_DEPARTED_VEHICLES_IDS,), begin=0, end=2**31 - 1, parameters=None):
672        """subscribe(list(integer), double, double, map) -> None
673
674        Subscribe to one or more simulation values for the given interval.
675        """
676        Domain.subscribe(self, "", varIDs, begin, end, parameters)
677
678    def getSubscriptionResults(self):
679        """getSubscriptionResults() -> dict(integer: <value_type>)
680
681        Returns the subscription results for the last time step.
682        It is not possible to retrieve older subscription results than the ones
683        from the last time step.
684        """
685        return Domain.getSubscriptionResults(self, "")