Overview demo
This video is a demonstration of simulating traffic flow within and between intersections/local networks using a tcp/ip server and multiple clients. The clients have factories that either create cars or receive them from the server. The client then simulates the traffic flow until the cars arrive at a "sink" or graph exit. The sink may be a normal sink or a network sink. For a normal sink, the vehicles are simply removed from the graph. If it is a network sink the car data is sent on to the server.
http://www.youtube.com/watch?v=f1qgI55ULIY
RNS Basics
Helpers includes a few utility or helper classes. For instance an easy way to get the local machine name and a StopWatch class.
Demos are examples that demonstrate the basic serial and threaded worlds as well as the distributed clients. The Repeater class in the distributed package has a main() which works as the server.
The Render package has a text render which is used to output information about the network structure and the location of vehicles on the network.
http://www.youtube.com/watch?v=1ndETp0ALHA
RNS Basics Part 2
In this video I will review, links, connectors, vehicle factories and Cars.
Links can be thought of as stretches of road. There was some initial code put in place for using coordinates to describe the link geometry. Links are the logical area where you will find cars. Sinks and factories are also special types of links. Sinks destroy cars and factories create them.
Connectors can be thought of as intersections. They have entry and exit links. Imagine that you are driving in your car approaching an intersection. You are on an entry link to that connector. When you pass through the intersection to a connecting you road, you have driven onto an exit link.
A Vehicle Factory is used to bring cars onto the local graph.
Cars carry a globally unique identifier.
http://www.youtube.com/watch?v=mlTNdqSToTo
The World
The World Factory is used to create worlds. It can create serial or threaded worlds. It can be used to create several different road structures.
http://www.youtube.com/watch?v=jmsyjkdxIVg
The Server
The Repeater accepts client connections. It repeats the data from them to all other connected nodes along with the identity of the originating node. If it detects that a node has dropped it removes it from it's client list.
http://www.youtube.com/watch?v=ktHGs-DpgeA
Basics of a client node
A Distributed Client uses the DistributedWorldFactory to create an instance of a DistributedWorld. The DistributedWorld is very similar to the normal distributed world. However, it includes distributed links and the distributed vehicle factory. The world handles the connection with the server. When processing vehicles that are in sinks as part of the update method, outgoing vehicle is sent to the repeater/server if is a distributed link (sink). The world also receives the incoming repeated car data from the repeater. The world passes the data on to all listening factories. The distributed factory determines if it needs the information. If it does, it places it in an incoming queue. Then when the world asks for a shipment from the factory, the factory sends the information about the cars that are in the queue. Even while the world is adding new information to the queue!
http://www.youtube.com/watch?v=Cc1nYuTujZY
Network and Node configurations
Node A configuration
This node starts with a normal factory. It is connected to a link which is in turn connected to a network sink. The network sink relays information to the repeater.
Node B configuration
This node has a distributed factory which is listening for car data that originates from Node A. It is connected to a link which is in turn connected to a network sink. The network sink relays information to the repeater.
Node C configuration
This node has a distributed factory which is listening for car data that originates from Node B. It is connected to a link which is in turn connected to a normal sink. The normal sink simply removes the cars from the local graph.
Files
You can get a JAR with the code here http://dbbear.com/TrafficFlowSimulator.jar
Sample output, which corresponds to the video run can be obtained here:
- http://dbbear.com/tfs_repeater.txt
- http://dbbear.com/tfs_nodeA.txt
- http://dbbear.com/tfs_nodeB.txt
- http://dbbear.com/tfs_nodeC.txt
Conclusions
A developer using this code structure will need to be careful to not have multiple distributed factories that pull from the same network sink. If this were to happen we'd have cloned cars in the overall network.
Association of vehicles with graph objects seems awkward. In a system that is highly focused on traffic a system that uses GIS type concepts would likely be better.
While this code may not be ideal for true traffic simulation because of the way vehicles are associated with individual graph elements, it does a good job of demonstrating threading and client-server based communication.
