Traffic simulation using Simpy

huangapple
go评论84阅读模式
英文:

Traffic simulation using Simpy

问题

我已经使用代码翻译了您提供的文本，以下是翻译好的部分：

  1. 我一直在使用Simpy来设计一个信号控制的交叉口的交通模拟（三个进口道）。附加的代码描述了汽车在单车道道路上行驶并仅从一个方向到达交叉口的设计。交通信号在绿灯和红灯之间切换。我的问题是：如何修改代码以模拟多个具有不同到达率的交通信号，这些信号按顺序在同一个交叉口工作。我的目标是将多个道路连接到交叉口，并通过交通信号控制交通流动。
  3. 提前致谢。
  5. # 然后是代码的部分...

请注意，代码部分未进行翻译。如果您需要进一步的帮助或有其他问题，请随时提出。

英文:

I have been working on simpy to design a traffic simulation of a signalized intersection (three approaches). The attached code described the design of the cars driving on a single lane road and arrive at the intersection from one direction only. The traffic light switching between green and red intervals. my question is: how to modify the code to simulate more than one traffic signal with different arrival rate that work in sequence at the same intersection. My goal is to connect more than one road to the intersection and control the traffic movement by a traffic signal.

Thanks in advance.

  1. # Section 1: Import from modules and define a utility class.
  3. from collections import deque # double-ended queue
  4. from numpy import random
  5. import simpy
  6. from simpy.util import start_delayed
  9. class Struct(object):
  10.    """
  11.    This simple class allows one to create an object whose attributes are
  12.    initialized via keyword argument/value pairs.  One can update the attributes
  13.    as needed later.
  14.    """
  15.    def __init__(self, **kwargs):
  16.       self.__dict__.update(kwargs)
  19. # Section 2: Initializations.
  21. random.seed([1, 2, 3])
  23. # Total number of seconds to be simulated:
  24. end_time= 200.0
  26. # Cars cars arrive at the traffic light according to a Poisson process with an
  27. # average rate of 0.2 per second:
  28. arrival_rate= 0.2
  29. t_interarrival_mean= 1.0 / arrival_rate
  31. # Traffic light green and red durations:
  32. t_green= 30.0; t_red= 40.0
  34. # The time for a car at the head of the queue to depart (clear the intersection)
  35. # is modeled as a triangular distribution with specified minimum, maximum, and
  36. # mode.
  37. t_depart_left= 1.6; t_depart_mode= 2.0; t_depart_right= 2.4
  39. # Initially, no cars are waiting at the light:
  40. queue= deque()
  42. # Track number of cars:
  43. arrival_count= departure_count= 0
  45. Q_stats= Struct(count=0, cars_waiting=0)
  46. W_stats= Struct(count=0, waiting_time=0.0)
  49. # Section 3: Arrival event.
  51. def arrival():
  52.    """
  53.    This generator functions simulates the arrival of a car.  Cars arrive
  54.    according to a Poisson process having rate `arrival_rate`.  The times between
  55.    subsequent arrivals are i.i.d. exponential random variables with mean
  57.       t_interarrival_mean= 1.0 / arrival_rate
  58.    """
  59.    global arrival_count, env, light, queue
  61.    while True:
  62.       arrival_count+= 1
  64.       if light == 'red' or len(queue):
  66.          # The light is red or there is a queue of cars.  ==> The new car joins
  67.          # the queue.  Append a tuple that contains the number of the car and
  68.          # the time at which it arrived:
  69.          queue.append((arrival_count, env.now))
  70.          print("Car #%d arrived and joined the queue at position %d at time "
  71.            "%.3f." % (arrival_count, len(queue), env.now))
  73.       else:
  75.          # The light is green and no cars are waiting.  ==> The new car passes
  76.          # through the intersection immediately.
  77.          print("Car #%d arrived to a green light with no cars waiting at time "
  78.            "%.3f." % (arrival_count, env.now))
  80.          # Record waiting time statistics.  (This car experienced zero waiting
  81.          # time, so we increment the count of cars, but the cumulative waiting
  82.          # time remains unchanged.
  83.          W_stats.count+= 1
  85.       # Schedule next arrival:
  86.       yield env.timeout( random.exponential(t_interarrival_mean))
  89. # Section 4: Define event functions.
  91. # Section 4.1: Departure event.
  93. def departure():
  94.    """
  95.    This generator function simulates the 'departure' of a car, i.e., a car that
  96.    previously entered the intersection clears the intersection.  Once a car has
  97.    departed, we remove it from the queue, and we no longer track it in the
  98.    simulation.
  99.    """
  100.    global env, queue
  102.    while True:
  104.       # The car that entered the intersection clears the intersection:
  105.       car_number, t_arrival= queue.popleft()
  106.       print("Car #%d departed at time %.3f, leaving %d cars in the queue."
  107.         % (car_number, env.now, len(queue)))
  109.       # Record waiting time statistics:
  110.       W_stats.count+= 1
  111.       W_stats.waiting_time+= env.now - t_arrival
  113.       # If the light is red or the queue is empty, do not schedule the next
  114.       # departure.  `departure` is a generator, so the `return` statement
  115.       # terminates the iterator that the generator produces.
  116.       if light == 'red' or len(queue) == 0:
  117.          return
  119.       # Generate departure delay as a random draw from triangular distribution:
  120.       delay= random.triangular(left=t_depart_left, mode=t_depart_mode,
  121.         right=t_depart_right)
  123.       # Schedule next departure:
  124.       yield env.timeout(delay)
  127. # Section 4.2: Light change-of-state event.
  129. def light():
  130.    """
  131.    This generator function simulates state changes of the traffic light.  For
  132.    simplicity, the light is either green or red--there is no yellow state.
  133.    """
  134.    global env, light
  136.    while True:
  139.       # Section 4.2.1: Change the light to green.
  141.       light= 'green'
  142.       print("\nThe light turned green at time %.3f." % env.now)
  144.       # If there are cars in the queue, schedule a departure event:
  145.       if len(queue):
  147.          # Generate departure delay as a random draw from triangular
  148.          # distribution:
  149.          delay= random.triangular(left=t_depart_left, mode=t_depart_mode,
  150.            right=t_depart_right)
  152.          start_delayed(env, departure(), delay=delay)
  154.       # Schedule event that will turn the light red:
  155.       yield env.timeout(t_green)
  158.       # Section 4.2.2: Change the light to red.
  159.       light= 'red'
  160.       print("\nThe light turned red at time %.3f."   % env.now)
  162.       # Schedule event that will turn the light green:
  163.       yield env.timeout(t_red)
  166. # Section 4.3: Schedule event that collects Q_stats.
  168. def monitor():
  169.    """
  170.    This generator function produces an interator that collects statistics on the
  171.    state of the queue at regular intervals.  An alternative approach would be to
  172.    apply the PASTA property of the Poisson process ('Poisson Arrivals See Time
  173.    Averages') and sample the queue at instants immediately prior to arrivals.
  174.    """
  175.    global env, Q_stats
  177.    while True:
  178.       Q_stats.count+= 1
  179.       Q_stats.cars_waiting+= len(queue)
  180.       yield env.timeout(1.0)
  183. # Section 5: Schedule initial events and run the simulation.  Note: The first
  184. # change of the traffic light, first arrival of a car, and first statistical
  185. # monitoring event are scheduled by invoking `env.process`.  Subsequent changes
  186. # will be scheduled by invoking the `timeout` method.  With this scheme, there
  187. # is only one event of each of these types scheduled at any time; this keeps the
  188. # event queue short, which is good for both memory utilization and running time.
  190. print("\nSimulation of Cars Arriving at Intersection Controlled by a Traffic "
  191.   "Light\n\n")
  193. # Initialize environment:
  194. env= simpy.Environment()
  196. # Schedule first change of the traffic light:
  197. env.process(light())
  199. # Schedule first arrival of a car:
  200. t_first_arrival= random.exponential(t_interarrival_mean)
  201. start_delayed(env, arrival(), delay=t_first_arrival)
  203. # Schedule first statistical monitoring event:
  204. env.process(monitor())
  206. # Let the simulation run for specified time:
  207. env.run(until=end_time)
  210. # Section 6: Report statistics.
  212. print("\n\n      *** Statistics ***\n\n")
  214. print("Mean number of cars waiting: %.3f"
  215.   % (Q_stats.cars_waiting / float(Q_stats.count)))
  217. print("Mean waiting time (seconds): %.3f"
  218.   % (W_stats.waiting_time / float(W_stats.count)))

答案1

得分: 0

以下是您要翻译的代码部分：

  1. You need a master light controller to manage all your lights.  I used the subscribe / publish pattern where each lane subscribed to the light they are interested in with a callback function. the light uses these callback functions to publish when the light is on.  I treat red and green light as separate lights.  The master light controller rotates through all the lights, calling each light's subscribers' callback function when the light turns on.
  3. This models a cross road, If you want to model a tee, just comment out any one lane.
  5.     """
  6.         Simulation of a traffic intersection
  7.         
  8.         Has four main lanes of traffic: North, South, East, and West
  9.         for each direction there is also a turn lane: North left.... ect
  10.     
  11.         Assumes opposing lanes (such as North, and South) 
  12.         will have the same light color
  13.     
  14.         Light are manganed by a light controler
  15.     
  16.         Lanes "subscribe" to the light color they are interested in
  17.         with a callback function
  18.         When the light color comes on, the light control calls the callback
  19.         function of the lanes that subscribed to that light color
  20.     
  21.         When a lane has a green light, it sends cars through the intersection,
  22.         otherwise arriving cars accumulate in a queue
  23.     
  24.         Programmer: Michael R. Gibbs
  25.     """
  26.     
  27.     import simpy
  28.     import random
  29.     
  30.     class LightControl():
  31.         """
  32.             Controls the color and timing of the lights
  33.         """
  34.     
  35.         def __init__(self, env):
  36.     
  37.             self.env = env
  38.     
  39.             # subscrition lists for each color and direction combo
  40.             self.red_ns_subs = []
  41.             self.red_ns_left_subs = []
  42.     
  43.             self.red_ew_subs = []
  44.             self.red_ew_left_subs = []
  45.     
  46.             self.green_ns_subs = []
  47.             self.green_ns_left_subs = []
  48.     
  49.             self green_ew_subs = []
  50.             self green_ew_left_subs = []
  51.     
  52.             # start the lights
  53.             self.env.process(self.run_lights())
  54.     
  55.         def _braodcast(self, subscribers):
  56.             """
  57.                 utility to call the callback funcs for each subscriber
  58.             """
  59.     
  60.             for callback in subscribers:
  61.                 callback()
  62.     
  63.         def run_lights(self):
  64.             """
  65.                 controls the lights with a simple loop
  66.                 note different light have different times
  67.             """
  68.     
  69.             while True:
  70.     
  71.                 print(f'{self.env.now} ns left is green')
  72.                 self._braodcast(self.green_ns_left_subs)
  73.     
  74.                 yield self.env.timeout(60)
  75.     
  76.                 self._braodcast(self.red_ns_left_subs)
  77.                 self._braodcast(self.green_ns_subs)
  78.                 print(f'{self.env.now} ns is green')
  79.                 
  80.                 yield self.env.timeout(180)
  81.     
  82.                 self._braodcast(self.red_ns_subs)
  83.                 self._braodcast(self.green_ew_left_subs)
  84.                 print(f'{self.env.now} ew left is green')
  85.                 
  86.                 yield self.env.timeout(60)
  87.     
  88.                 self._braodcast(self.red_ew_left_subs)
  89.                 self._braodcast(self.green_ew_subs)
  90.                 print(f'{self.env.now} ew is green')
  91.                 
  92.                 yield self.env.timeout(120)
  93.     
  94.                 self._braodcast(self.red_ew_subs)
  95.     
  96.     class Lane():
  97.         """
  98.             lane of traffic
  99.     
  100.             accumulates cars,
  101.             waits for green light,
  102.             sends cars through interscetion, until red light
  103.     
  104.             note if a car is already in the intersection when
  105.             the light truns red, it will finish its trip and 
  106.             continue through
  107.         """
  108.     
  109.         def __init__(self, name, env):
  110.     
  111.             self.name = name
  112.             self.env = env
  113.             self.lane_q = []
  114.             self.green = False
  115.     
  116.         def add_car(self, car):
  117.             """
  118.             car arrives at lane
  119.             """
  120.     
  121.             self.lane_q.append(car)
  122.     
  123.         def move_cars(self):
  124.             """
  125.             move cars through the intersection until light turns red
  126.             """
  127.     
  128.             while self.green and (len(self.lane_q) > 0):
  129.     
  130.                 car = self.lane_q.pop(0)
  131.                 yield self.env.timeout(10)
  132.     
  133.                 print(f'{self.env.now} {self.name} sent car through')
  134.     
  135.         def green_light(self):
  136.             """
  137.             callback telling the lane that the light is green,
  138.             starts moving cars through the intersection
  139.             """
  140.     
  141.             self.green = True
  142.     
  143.             self.env.process(self.move_cars())
  144.     
  145.         def red_light(self):
  146.             """
  147.             callback telling the lane the light is red
  148.             sets stop flag
  149.             """
  150.     
  151.             self.green = False
  152.     
  153.     def gen_cars(env, lane, delay_func):
  154.         """
  155.         generates cars arriving at a lane
  156.         """
  157.     
  158.         while True:
  159.             yield env.timeout(delay_func())
  160.             lane.add_car(object())
  161.     
  162.     # init sim
  163.     env = simpy.Environment()
  164.     lights = LightControl(env)
  165.     
  166.     # make lanes and subscibe to a lights with a callback
  167.     north =Lane('North lane', env)
  168.     
  169.     lights.green_ns_subs.append(north.green_light)
  170.     lights.red_ns_subs.append(north.red_light)
  171.     
  172.     north_left =Lane('North left lane', env)
  173.     
  174.     lights.green_ns_left_subs.append(north_left.green_light)
  175.     lights.red_ns_left_subs.append(north_left.red_light)
  176.     
  177.     south =Lane('South lane', env)
  178.     
  179.     lights.green_ns_subs.append(south.green_light)
  180.     lights.red_ns_subs.append(south.red_light)
  181.     
  182.     south_left =Lane('South left lane', env)
  183.     
  184.     lights.green_ns_left_subs.append(south_left.green_light)
  185.     lights.red_ns_left_subs.append(south_left.red_light)
  186.     
  187.     east =Lane('East lane', env)
  188.     
  189.     lights.green_ew_subs.append(east.green_light)
  190.     lights.red_ew_subs.append(east.red_light)
  191.     
  192.     east_left =Lane('East left lane', env)
  193.     
  194.     lights.green_ew_left_subs.append(east_left.green_light)
  195.     lights.red_ew_left_subs.append(east_left.red_light)
  196.     
  197.     west =Lane('West lane', env)
  198.     
  199.     lights.green_ew_subs.append(west.green_light)
  200.     lights.red_ew_subs.append(west.red_light)
  201.     
  202.     west_left =Lane('West left lane', env)
  203.     
  204.     lights.green_ew_left_subs.append(west_left.green_light)
  205.     lights.red_ew_left_subs.append(west_left.red_light)
  206.     
  207.     # generate cars for each lane
  208.     env.process(gen_cars(env, north, lambda : random.triangular(5,15,10)))
  209.     env.process(gen_cars(env, north_left, lambda : random.triangular(10,30,20)))
  210.     env.process(gen_cars(env, south, lambda : random.triangular(5,15,10)))
  211.     env.process(gen_cars(env, south_left, lambda : random.triangular(12,35,20)))
  212.     env.process(gen_cars(env, east, lambda : random.triangular(10,40,30)))
  213.     env.process(gen_cars(env, east_left, lambda : random.triangular(15,45,30)))
  214.     env.process(gen_cars(env, west, lambda : random.triangular(11,45,35)))
  215.     env.process(gen_cars(env, west_left, lambda : random.triangular(15,50
  217. <details>
  218. <summary>英文:</summary>
  220. You need a master light controller to manage all your lights.  I used the subscribe / publish pattern where each lane subscribed to the light they are interested in with a callback function. the light uses these callback functions to publish when the light is on.  I treat red and green light as separate lights.  The master light controller rotates through all the lights, calling each light&#39;s subscribers&#39; callback function when the light turns on.
  222. This models a cross road, If you want to model a tee, just comment out any one lane.
  224.     &quot;&quot;&quot;
  225.         Simulation of a traffic intersection
  226.         
  227.         Has four main lanes of traffic: North, South, East, and West
  228.         for each direction there is also a turn lane: North left.... ect
  229.     
  230.         Assumes opposing lanes (such as North, and South) 
  231.         will have the same light color
  232.     
  233.         Light are manganed by a light controler
  234.     
  235.         Lanes &quot;subscribe&quot; to the light color they are interested in
  236.         with a callback function
  237.         When the light color comes on, the light control calls the callback
  238.         function of the lanes that subscribed to that light color
  239.     
  240.         When a lane has a green light, it sends cars through the intersection,
  241.         otherwise arriving cars accumulate in a queue
  242.     
  243.         Programmer: Michael R. Gibbs
  244.     &quot;&quot;&quot;
  245.     
  246.     import simpy
  247.     import random
  248.     
  249.     class LightControl():
  250.         &quot;&quot;&quot;
  251.             Controls the color and timing of the lights
  252.         &quot;&quot;&quot;
  253.     
  254.         def __init__(self, env):
  255.     
  256.             self.env = env
  257.     
  258.             # subscrition lists for each color and direction combo
  259.             self.red_ns_subs = []
  260.             self.red_ns_left_subs = []
  261.     
  262.             self.red_ew_subs = []
  263.             self.red_ew_left_subs = []
  264.     
  265.             self.green_ns_subs = []
  266.             self.green_ns_left_subs = []
  267.     
  268.             self.green_ew_subs = []
  269.             self.green_ew_left_subs = []
  270.     
  271.             # start the lights
  272.             self.env.process(self.run_lights())
  273.     
  274.         def _braodcast(self, subscribers):
  275.             &quot;&quot;&quot;
  276.                 utility to call the callback funcs for each subscriber
  277.             &quot;&quot;&quot;
  278.     
  279.             for callback in subscribers:
  280.                 callback()
  281.     
  282.         def run_lights(self):
  283.             &quot;&quot;&quot;
  284.                 controls the lights with a simple loop
  285.                 note different light have different times
  286.             &quot;&quot;&quot;
  287.     
  288.             while True:
  289.     
  290.                 print(f&#39;{self.env.now} ns left is green&#39;)
  291.                 self._braodcast(self.green_ns_left_subs)
  292.     
  293.                 yield self.env.timeout(60)
  294.     
  295.                 self._braodcast(self.red_ns_left_subs)
  296.                 self._braodcast(self.green_ns_subs)
  297.                 print(f&#39;{self.env.now} ns is green&#39;)
  298.                 
  299.                 yield self.env.timeout(180)
  300.     
  301.                 self._braodcast(self.red_ns_subs)
  302.                 self._braodcast(self.green_ew_left_subs)
  303.                 print(f&#39;{self.env.now} ew left is green&#39;)
  304.                 
  305.                 yield self.env.timeout(60)
  306.     
  307.                 self._braodcast(self.red_ew_left_subs)
  308.                 self._braodcast(self.green_ew_subs)
  309.                 print(f&#39;{self.env.now} ew is green&#39;)
  310.                 
  311.                 yield self.env.timeout(120)
  312.     
  313.                 self._braodcast(self.red_ew_subs)
  314.     
  315.     class Lane():
  316.         &quot;&quot;&quot;
  317.             lane of traffic
  318.     
  319.             accumulates cars,
  320.             waits for green light,
  321.             sends cars through interscetion, until red light
  322.     
  323.             note if a car is already in the intersection when
  324.             the light truns red, it will finish its trip and 
  325.             continue through
  326.         &quot;&quot;&quot;
  327.     
  328.         def __init__(self, name, env):
  329.     
  330.             self.name = name
  331.             self.env = env
  332.             self.lane_q = []
  333.             self.green = False
  334.     
  335.         def add_car(self, car):
  336.             &quot;&quot;&quot;
  337.             car arrives at lane
  338.             &quot;&quot;&quot;
  339.     
  340.             self.lane_q.append(car)
  341.     
  342.         def move_cars(self):
  343.             &quot;&quot;&quot;
  344.             move cars through the intersection until light turns red
  345.             &quot;&quot;&quot;
  346.     
  347.             while self.green and (len(self.lane_q) &gt; 0):
  348.     
  349.                 car = self.lane_q.pop(0)
  350.                 yield self.env.timeout(10)
  351.     
  352.                 print(f&#39;{self.env.now} {self.name} sent car through&#39;)
  353.     
  354.         def green_light(self):
  355.             &quot;&quot;&quot;
  356.             callback telling the lane that the light is green,
  357.             starts moving cars through the intersection
  358.             &quot;&quot;&quot;
  359.     
  360.             self.green = True
  361.     
  362.             self.env.process(self.move_cars())
  363.     
  364.         def red_light(self):
  365.             &quot;&quot;&quot;
  366.             callback telling the lane the light is red
  367.             sets stop flag
  368.             &quot;&quot;&quot;
  369.     
  370.             self.green = False
  371.     
  372.     
  373.     def gen_cars(env, lane, delay_func):
  374.         &quot;&quot;&quot;
  375.         generates cars arriving at a lane
  376.         &quot;&quot;&quot;
  377.     
  378.         while True:
  379.             yield env.timeout(delay_func())
  380.             lane.add_car(object())
  381.     
  382.     # init sim
  383.     env = simpy.Environment()
  384.     lights = LightControl(env)
  385.     
  386.     # make lanes and subscibe to a lights with a callback
  387.     north =Lane(&#39;North lane&#39;, env)
  388.     
  389.     lights.green_ns_subs.append(north.green_light)
  390.     lights.red_ns_subs.append(north.red_light)
  391.     
  392.     north_left =Lane(&#39;North left lane&#39;, env)
  393.     
  394.     lights.green_ns_left_subs.append(north_left.green_light)
  395.     lights.red_ns_left_subs.append(north_left.red_light)
  396.     
  397.     south =Lane(&#39;South lane&#39;, env)
  398.     
  399.     lights.green_ns_subs.append(south.green_light)
  400.     lights.red_ns_subs.append(south.red_light)
  401.     
  402.     south_left =Lane(&#39;South left lane&#39;, env)
  403.     
  404.     lights.green_ns_left_subs.append(south_left.green_light)
  405.     lights.red_ns_left_subs.append(south_left.red_light)
  406.     
  407.     east =Lane(&#39;East lane&#39;, env)
  408.     
  409.     lights.green_ew_subs.append(east.green_light)
  410.     lights.red_ew_subs.append(east.red_light)
  411.     
  412.     east_left =Lane(&#39;East left lane&#39;, env)
  413.     
  414.     lights.green_ew_left_subs.append(east_left.green_light)
  415.     lights.red_ew_left_subs.append(east_left.red_light)
  416.     
  417.     west =Lane(&#39;West lane&#39;, env)
  418.     
  419.     lights.green_ew_subs.append(west.green_light)
  420.     lights.red_ew_subs.append(west.red_light)
  421.     
  422.     west_left =Lane(&#39;West left lane&#39;, env)
  423.     
  424.     lights.green_ew_left_subs.append(west_left.green_light)
  425.     lights.red_ew_left_subs.append(west_left.red_light)
  426.     
  427.     # generate cars for each lane
  428.     env.process(gen_cars(env, north, lambda : random.triangular(5,15,10)))
  429.     env.process(gen_cars(env, north_left, lambda : random.triangular(10,30,20)))
  430.     env.process(gen_cars(env, south, lambda : random.triangular(5,15,10)))
  431.     env.process(gen_cars(env, south_left, lambda : random.triangular(12,35,20)))
  432.     env.process(gen_cars(env, east, lambda : random.triangular(10,40,30)))
  433.     env.process(gen_cars(env, east_left, lambda : random.triangular(15,45,30)))
  434.     env.process(gen_cars(env, west, lambda : random.triangular(11,45,35)))
  435.     env.process(gen_cars(env, west_left, lambda : random.triangular(15,50,40)))
  436.     
  437.     env.run(1200)
  439.     
  440.             
  446. </details>

huangapple
  • 本文由 发表于 2023年2月18日 01:07:58
  • 转载请务必保留本文链接：https://go.coder-hub.com/75487283.html
  • intersection
  • python
  • simpy
  • traffic-simulation
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定