Posted by Wordmobi

Building an LFS system is not a simple task. The following are the recommended pre-requisites from the book for novice users:

• Software-Building-HOWTO
  http://www.tldp.org/HOWTO/Software-Building-HOWTO.html
  This is a comprehensive guide to building and installing “generic” Unix software packages under Linux.
• The Linux Users’ Guide
  http://www.linuxhq.com/guides/LUG/guide.html
  This guide covers the usage of assorted Linux software.
• The Essential Pre-Reading Hint
  http://www.linuxfromscratch.org/hints/downloads/files/essential_prereading.txt
  This is an LFS Hint written specifically for users new to Linux. It includes a list of links to excellent sources of information on a wide range of topics. Anyone attempting to install LFS should have an understanding of many of the topics in this hint.

I haven’t yet built the system but slowly and surely am moving towards it. When I do however build it, I will write up something about my experiences and put it here. So, watch this space…

FYI: Internet Explorer 7 sometimes has issues displaying the favicon.
My recommendation: Use Opera. Click here to download.

I love music and being able to create it will have an extra sense of pleasure. Although learning musical instruments would be ideal (also something I’m getting at), I think this is definitely NOT a step in the wrong direction.

QuarkXPress (“Quark”) is a computer application for creating and editing complex page layouts in a WYSIWYG (What You See Is What You Get) environment. It runs on Mac OS X and Windows. It was first released by Quark, Inc. in 1987 and is still owned and published by them. The most recent version is 7.3 and includes editions for publishing in American English, International English, and over a dozen other languages. QuarkXPress is primarily used by large publishing houses to produce the kinds of complex page layouts required by magazines, newspapers, catalogs, and similar printed materials. It is one of two products (the other being Adobe InDesign) that dominate that market space. 

Not so long ago, one of the things that I tried starting at Drexel, along with some freshmen, was a magazine. MediuM, as it was to be called, eventually got shelved primarily in part because of the lack of people (including me) not knowing the preferred software for publishing literature, QuarkXpress. So, I’ve decided to learn it.

eg: for input a,b,c; the output will be:
line = ‘a,b,c’
field[0] = `a’
field[1] = `b’
field[2] = `c’

The example above is the simplest of examples. However, the program below can handle complex ones also. It can deal with spaces or consecutive commas and semicolons. Try it out. By the way, I used netbeans for this project; it’s pretty good. Download link at end of page.

The CSV class file:

/*
* Csv.java
*
* Created on May 29, 2007, 4:26 AM
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

package csv;

import java.util.*; //This will be used to work with lists.
import java.lang.String; //This will be used for string manipulations.

/**
*
* @author Amar Maniar
*/
public class Csv { //This class will handle all the logic need to parse CSV files.

private
int nfield; //This will hold the number fields that were seperated by commas.
char fieldSep; //This will hold the actual field seperator. For this exercise it is “,”
List field = new ArrayList(); //This will hold the actual values that were comma seperated.
String fld = new String(); //Will be used as a temporary variable that will hold each field
//before its placed in the final list.

public int split(String line) { //This function will split the input on commas.
//It needs to decide whether to parse normally
//or consider special scenarios like “Amar,Maniar”.
//This function returns the number of fields present
//in the input.
int i, j;
fld = “”;

nfield = 0;
if (line.length() == 0) //If the input line length is 0, then there are no fields
return 0; //there fore the return value is 0.
i = 0;
do {
if (i < line.length() && line.charAt(i) == ‘”‘) //If quotes are present in the input handle
j = advquoted(line, ++i); //them specially, by calling the advqouted method.
else
j = advplain(line, i); //Else just handle them normally.

field.add(fld); //Once any of the above functions return, the fld string will be set.
//This value of fld should be placed in the final list, so that fld can
//now take the next parsed value.
nfield++; //The value of number of fields prased will also increase by one.
i = j + 1; //This line will increment the index for the over all input. The value of j is set by
//either advquoted or advplain, where j is the index value of the last read character.
} while (j < line.length()); //Processing runs untill there are no more character to be read.

return nfield; //Return the number of fields parsed.
}

public int advplain(String line, int i) { //This function will parse all fields that are not in quotes. advplain – advance for plain input
int j;

j = line.indexOf(fieldSep, i); //This will give the index of the next occurance
//of filed seperator starting from i.
//i is the current location of parser in the
//over all input.

if (j == -1) {
fld = line.substring(i); //If there is no such field then just return length of line.
return line.length(); //This means that there are no more fields left to seperate.
} else
fld = line.substring(i,j); //Else return the substring between i and j. Eg: ,123, i=first comma j=second comma
return j; //therefore substring will hold 123. Here j is returned, that index of last character read.
} //Fld will hold 123 which will be placed in the final list of fields.

public int advquoted(String line, int i) { //This function will parse all fields that are in quotes. advquoted – advance for quoted input
int j;
fld = “”;
for (j=i; j<line.length(); j++) { //to move from the current location (which is i) to the end(the length of the string)
if (line.charAt(j) == ‘”‘ && j+1 < line.length()) { //If the the current location has a ‘”‘ and if the next location is not the end
if (line.charAt(j+1) == ‘”‘) { //if the next location is a ‘”‘
j++; //go to the next location
} else if (line.charAt(j+1) == fieldSep) { //or if the next location is our field separator, a comma
j++; //go the next location and break since we’re done one case of quotes, the beginning ones
break;
}
} else if (line.charAt(j) == ‘”‘ && j+1 == line.length()) { //now, if the ‘”‘ is the last, i.e. at the end of the string
break; //done //we’re done
}
fld = fld+line.charAt(j); //so, now the field to be dealt with is where it’s currently at added to j, the position after
} //dealing with quoted text
return j; // returning the current position
}
/** Creates a new instance of Csv */
public Csv() { //This is the default constructor for the class
fieldSep = ‘,’; //The default field seperator is “,” (this can be changed to anything and it would act like a separator
}
public Csv(char sep) { //This constructor can be used when a different
fieldSep = sep; //field seperator needs to be used. Like for example |
}

public String getfield(int n) { //This function will return the field values
if (n < 0 || n >= nfield) //from the final list, and these values are
return “”; //indexed from 1 to n, where n is the total
else //number of fields. Once we reach the max number
return field.get(n).toString(); //of fields, any more queries will return empty strings.
}

public int getnfield() { //This function will return the total number of lists parsed.
return nfield;
}
}

The Main class file:

/* class Main.
* This is the driver class, that will take user input
* either directly or as a file. It will then output
* various fields that were comma seperated.
*/

import csv.*; // this is the class that I created
import java.io.*; //We need this to be able to access user input or files.

public final class Main {
/** Constructor. */
public Main() {}

public static void main(String[] args) throws IOException {
int n;
int i = 0;
String line = new String();

if (args.length == 0) { //If no arguments were provided then user will input
// the comma seperated values.
BufferedReader is = new BufferedReader(new InputStreamReader(System.in)); //Allows us to access and perform
//actions on the input from the console.
while ((line = is.readLine()) != null) { //In a continuous while loop
//so as to access user input and parse
//it.
Csv csv = new Csv(); //Instantiate the csv object, so that parsing can be done.
System.out.println(“line = `” + line + “‘”); //Print the unparsed line.
n = csv.split(line); //Calls the split method, that will spit the line into various fields
//and returns the number of fields that were obtained after the split.
while (i<n) { //Print the various fields that were obtained after the input line was split.
System.out.println(“field[" + i + "] = `” + csv.getfield(i) + “‘”);
i++;
}
}
} else {
for (i=0; i<args.length; i++) { //User specified which file to read the input from.
BufferedReader is = new BufferedReader(new FileReader(args[i])); //Allows us to access and perform
//actions on the input from file.
while ((line = is.readLine()) != null) {
Csv csv = new Csv(); //Instantiate the csv object, so that parsing can be done.
System.out.println(“line = `” + line + “‘”); //Print the unparsed line.
n = csv.split(line); //Calls the split method, that will spit the line into various fields
//and returns the number of fields that were obtained after the split.
i = 0;
while (i<n) { //Print the various fields that were obtained after the input line was split.
System.out.println(“field[" + i + "] = `” + csv.getfield(i) + “‘”);
i++;
}
}
}

}
}

}

Click here to download with the “Read Me” file (includes makefile also)

NAT stands for Network Address Translation. It is a standard that enables a local-area network (LAN) to use one set of IP addresses for internal traffic and a second set of addresses for external traffic.

The Problem: The router gives everyone on the network a different set of IP addresses and itself has a different one. Therefore, even after you know the IP address from the link above, there is needed a way to reach your computer on the network. 

The solution: It is actually very simple. In a nutshell, you need to tell your modem to route any incoming remote desktop connections to your computer. By default, the modem does not know how to respond. The idea is to have the application level gateway on your modem use a rule (specified by you) when dealing with communication on a specific port on your computer (for remote desktop, it is 3389). The official term for this is port forwarding. Refer to the tutorial below:

Tutorial:

First of all, you need to get into your router. One of the most common addresses is http://192.168.1.1; you need to find out the one for yours. You can search for it on any search engine or the router documentation would definitely have it.

After you do that, you will asked for a username and password. Some of the common ones are:

Next, something like this will open up:

You need to click on Setup/Configuration.

Then click on Advanced Setup.

Click to Begin Advanced Setup.

Now, click on Application Level Gateway to open up something as shown above. Then select the User radio button. The Available Rule “remote” was created by me.

To create a rule, click on New. It will open up Rule Management; fill in the information as shown below and hit Apply.

Now that you’ve created the rule, go back to the previous page by clicking Back.

As shown above, you now need to add that rule to a LAN device; this dropdown list will contain computers on the network by their names. So, my computer being ragno, I selected it and added the rule “remote” to it. When you’re done with that, just hit Save and Restart.

The router will restart and then when you put in your “real” IP address when you’re out somewhere, the remote desktop connection is forwarded to your computer and you can connect to your computer. IP addresses on your network will have the same “real” IP address, so don’t use any of them. Although for using remote desktop from your own network, you’d just need the name of your computer.

However, IP addresses are hard to remember. To deal with that, you can get a DNS hostname. It is available for free at no-ip.com. DNS hostname is basically just a name associated with your IP address. You will need to download a client that will update everytime your IP address changes (IP addresses change when they are dynamic, which is the case for homes).

Food for thought: I think with this, it is only one computer on the network that can be ‘remote desktop’ed into; since every other windows machine will have the same remote desktop port. I haven’t researched into how to do this on several computers or if it is even possible.

Feel free to comment and give suggestions.

FMVD 125 – Basic Television Studio
It covers the basics of television studio operation through a series of exercises in a workshop setting, culminating in projects written and produced by the students.

My team included Krystal & Me; hence the title. This was sort of our final, wherein we were given about one and a half hours to produce a short story (about 2-3 minutes) utilizing all the TV equipment and man-power that was available; the man-power being the rest of the class. The catch was, we cannot edit it once it is recorded which meant that it has to be one perfect take. Getting the crew to understand your vision and have them do exactly what you want, when you want takes quite a bit of effort in that allotted time. However, we got through it and it was fun!!

The script can be found here (.pdf); I think we did good in the allotted time.

Script nomenclature: (also: left side is camera shots and right is dialogue & action)
CU – Close Up, MS – Medium Shot, LS – Long Shot, ELS – Extra Long Shot, CG – Computer Graphics
OTS – Over The Shoulder
The numbers before the shots are camera numbers.
There were 3 cameras that we could use at any given time.

Library ieee;
Use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;

entity RAM_tb is
constant ntb: natural := 8;
constant mtb: natural := 4;
end RAM_tb;

architecture bt_MAR of RAM_tb is

component RAM
generic(m:natural:=4;n:natural:=8);
port(clk,clr,rw:in std_logic; addrbus:in std_logic_vector(m-1 downto 0);
 databus:inout std_logic_vector(n-1 downto 0));
end component;

type array_tb is array(natural range <>) of std_logic_vector(ntb-1 downto 0);
type array_tb2 is array(natural range <>) of std_logic_vector(mtb-1 downto 0);
signal abus: array_tb2((mtb-2) downto 0) := (“0010″,”0001″,”0000″);
signal dbus: array_tb((mtb-2) downto 0) := (“00000000″,”UUUU0000″,”UUUUUUUU”);

–type ram_type is array(0 to n-1) of std_logic_vector(n-1 downto 0);
–signal ramram: ram_type;
signal cr,rww: std_logic;
signal adrbus: std_logic_vector(mtb-1 downto 0);
signal dtbus: std_logic_vector(ntb-1 downto 0);
signal ck: std_logic := ’1′;

type state is (start,assign,writeit,readit,check,over);
signal n_s:state;

begin
ck <= not ck after 50 ns;

R: RAM port map(ck,cr,rww,adrbus,dtbus);

Process(ck)
variable i: integer:=0;
begin
 case n_s is
  when start =>
   n_s <= assign;
 
  when assign =>
   cr<=’0′;
   adrbus<=abus(i);
   dtbus<=dbus(i);
   n_s<=writeit;
   
  when writeit =>
   cr<=’1′;
   rww<=’1′;
   n_s<=readit after 50 ns;
  
  when readit =>
   rww<=’0′;
   adrbus<=abus(i);
   n_s<=check after 50 ns;
  
  when check =>
   assert(dtbus=dbus(i)) report “RAM ERROR” severity error;
   i:=i+1;
   if (i<(mtb-1)) then
    n_s<=assign;
   else
    n_s<=over;
   end if;
   
  when over =>
   assert(false) report “TEST DONE” severity failure;
   
 end case;
end process;
end bt_MAR;

It worked the last time I checked. You might have to deal with formatting issues. As for the RAM, you can create one based on this test bench. If I feel like it, I might write it up and post it here.

TCP is part of the transport layer as shown below. The transport layer is not just any other layer. It is the heart of the whole protocol hierarchy. Its task is to provide reliable, cost-effective data transport from the source machine to the destination machine, independently of the physical network or networks currently in use. Without the transport layer, the whole concept of layered protocol would make little sense.

The ultimate goal of the transport layer is to provide efficient, reliable and cost-effective service to its users, normally processes in the application layer. To achieve this goal, the transport layer makes use of the services provided by the network layer.

The internet has two main protocols in the transport layer, a connectionless protocol and a connection-oriented one. The former one is UDP (User Datagram Protocol) and the latter is the topic of our discussion, TCP (Transmission Control Protocol). UDP provides a way for applications to send encapsulated IP datagrams and send them without having to establish a connection. It is a simple protocol and it has some niche uses, such as client-server interactions and multimedia, but for most Internet applications, reliable, sequential delivery is needed. UDP cannot provide this, so another protocol is required. It is called TCP and is the main workhorse of the Internet.

TCP was specifically designed to procide a reliable end-to-end byte stream over an unreliable internetwork. An internetwork differs from a single network because different parts may have wildly different topologies, bandwidths, delays, packet sizes, and other parameters. TCP was designed to dynamically adapt to properties of the internetwork and to be robust in the face of many kinds of failures. Therefore, packets (information) sent need to be acknowledged after they are received.

A max of W-unacknowledged packets can be in the network at any time, where W being the window size. If W=0, the sender halts transmission. This is the sliding window of transmission. Below is the slow start mechanism used by TCP to probe network bandwidth.

A transmission starts with W=1. If it is successful, the window size doubles to become W=W x 2 (so, 2, 4, etc..). If a packet is lost, then W becomes 1 all over again and then the window again ramps up to the max size it can achieve. This size depends on the network since this is the TCP way to probe network for bandwidth.

In theory, transport protocols should be independent of the technology of the underlying layer. In particular, TCP should not care whether IP is running over fiber or over radio. In practice, it does matter because most TCP implementations have been carefully optimized based on assumptions that are true for wired networks but that fail for wireless networks. Ignoring the properties of wireless transmission can lead to horrendous performance even though the logic behind it is sound. The inherent instability of wireless networks is the main concern here. There tend to be disconnections and bandwidth fluctuations. With regular TCP described above, the slow start mechanism will start over and over in an instable wireless environment. Therefore, TCP implementations better able to adapt to the challenges of wireless networks need to be used. See figure below. Click for bigger picture.

Two implementations optimized for wireless networks that we worked with were TCP Fast Start and Freeze-TCP. The figure below shows you how Freeze-TCP that is primarily designed to deal with disconnection events handles them as opposed to regular TCP.

TCP Fast Start is primarily designed for dealing with idle periods i.e. periods of no use of network bandwidth. In the case regular TCP, the window size would begin from W=1 after an idle period and then ramp back up. In the case of TCP Fast Start, it will start from the window size used before the idle period. The congestion window size and other relevant parameters are cached for this.

Our project involved in combining the features of each of these implementations into a TCP hybrid protocol. The results of our hybrid in a simulated enviorment are shown below. Ethereal was our packet sniffer.

Feel free to comment and leave suggestions.

In studying traffic, there are two approaches to modeling that are used as a result of the dynamical problems which can not be described in analytical terms, they are stochastic and deterministic models. Deterministic models are created by exact mathematical relationships. Stochastic approaches have processes that include probabilistic density functions to describe an event in the system.  Three types of simulations exist microscopic, macroscopic, and mesoscopic. Mesoscopic models describe all states of the system at a high level but with less attention to the interactions of the vehicles/drivers. Macroscopic models manifest the traffic system as it is perceived, for example the wave that describes the flow of traffic on a congested highway. Microscopic models exemplifies the interactions of state of they system in high level of detail, for example lane changing. The majority of traffic simulations are dynamical which show how the setting changes or evolves from one moment of time to the next. Continuous simulations express how the elements change continuously over time in response to instantaneous inputs. Discrete simulations represent real world systems and change state at discrete intervals of time or at discrete events. 

A Stochastic process is a non-countable infinity of random variables, one for each time t. In stochastic analysis uniform random generation is used commonly as inputs to the random variables. Uniform distributions have a probability density function in the form of , where a and b are constants. Two processes are generally used to describe traffic flow; they are Random Walks and Poisson processes. A Random Walk is a sequence of independent random variables. In two dimensions a random walk has the probability of unity for reaching any point in the system as the number of steps approaches infinity. A random walk can be used to model a non-linear system, (a system that is a function of time and position). Poisson Process is a process that satisfies the following properties, the number of changes in nonoverlapping intervals is independent for all intervals, the probability of two or more changes in a small interval is zero and the probability of one change in a small interval is the probability of change divided by the total number of trials. A Poisson Process has the probability density function in the form:

Single Phase Fluid Model:

Single Phase fluid model was proposed in 1955 by Lighthill and Whitham and again by Richards in 1956. Their traffic models became commonly referred to as the LWR kinematic model. The LWR model for single lane traffic on a unidirectional highway follows the mass conservation law or “conservation of car law”.

Density (ρ) is the density of cars as a function of time of distance x and time t and v(x, t) is the velocity of the car located at point x at time t. The LWR model makes the assumption that the v is a function of density only which allows the driver to instantaneously adjust his velocity to the local car density.

Vmax is a maximum velocity a driver could go on a free highway, and V (ρ) is a ‘hindrance’ function taking into account the presence of other cars(which cause the driver to decelerate).  ρmax is the maximum car density corresponding to the ‘bumper-to-bumper’ traffic. 

Haight in 1974 expressed the fundamental diagram for traffic into seven types state equations. None of the models can be directly applied to mixing traffic.

However, improvements to the model were made by Daganzo in 1995. Daganzo show that the LWR model for traffic on freeways was inaccurate.  It was determined that because of the mixing traffic flow the LWR model needs to be modified to evaluate the system.

Two Phase Fluid Model:

The first two fluid model for traffic was developed by Herman and Prigogine in 1979 and is based on the mass conservation law. The traffic is viewed as slow moving and fast moving traffic. The vehicles for freeway models are composed into two parts, density and speed. Using mixing traffic flow on freeways the vehicles are divided into slow moving and fast moving clusters. The flow does not take into account different lanes. ‘s’ is the fraction of mass from the first phase (slow cars), u1f and u2f represent the free speeds of the (slow, fast respectively) traffic. Where as u1  and u2 are the speeds relative to each other.

K1(s) and K2(s) are monotonic functions which represent the vehicle interaction, the slow moving traffic cannot be affected by the fast moving traffic therefore K1(s)=1. However as the slow moving traffic becomes more congested then the fast moving cluster of traffic must decrease speed.

The polynomial speed density, and the maximum global density is defined by . This is the ck function seen by the generalized random walk process. 

Leader Follower Model:

The leader follower model is a fundamental interaction shown in microscopic traffic simulation models. It is a group of vehicles or a vehicles traveling in the same lane behind a faster moving car known as the leader. The vehicle is affected only by the vehicle directly ahead of it, the follower tries to decelerate or accelerate depending on the distance between the car in front of it or its speed. The interaction between the leader and followers acts as the stimulating response to the system.

‘t’ represents time, τ is the reaction time and Xn is the position of the nth car,  λ is the sensitivity coefficient which depends on parameters including the distance between cars and the speed if nth car. For λτ > nπ the traffic is unstable (n = multiples of pi) and for  λτ ≤ nπ the system is stable.1

Reaction Time of Driver:

The reaction time of a driver can be decomposed into mental processing time, movement time, and device response time. An expecting driver is classified as alert and aware of the possibility that braking will be necessary.  The estimate used is 0.7 second which is comprised of 0.5 seconds for perception and 0.2 seconds for movement, the time required to release the accelerator and to depress the brake pedal. However a more common used estimate for response time is 1.1 seconds. Standard reaction time for evening light the reaction time is increased by 20-25 ms. An unexpected driver is one who detects a common road signal such as a brake from the car ahead or from a traffic signal. The reaction time increases to 1.25 seconds. This is due to the increase in perception time to over a second with movement time still about 0.2 second.  A surprise driver encounters an unusual circumstance, such as a pedestrian or another car crossing the road in the near distance. There is extra time needed to interpret the event and to decide upon response. The standard reaction time is 1.5 seconds the perception time is 1.2 seconds while movement time increases to 0.3 seconds. The affect of age on response time can not be a factor since studies present conflicting arguments.

Background:

First Order Systems:

Pole – The first order system has a single pole at -a.  If the pole is on the negative real axis, then the system is stable.  If the pole is on the positive real axis, then the system is unstable. 

Zero -The zeros of a first order system are the values of s which makes the numerator of the transfer function equal to zero.
Second Order Systems:

Natural Frequency – The natural frequency is the frequency at which the system would oscillate if there were no damping (ie. if ζ = 0).

  
 
Damping Ratio – Is the ratio of the exponential decay frequency to the natural frequency. 

Rise Time – Time required for the waveform to go from 0.1 of the final value to 0.9 of the final value.

Peak Time – Time required for the waveform to reach the first maximum peak

Settling Time – Is the time it takes for the amplitude of a decaying sinusoid to reach 0.02.

Percent Overshoot – The percent overshoot is the maximum fraction by which the response overshoots the steady state value expressed as a percentage.

Pole – There are two poles in a second order system -ζωn ± jωn  sqrt(1-ζ2.  When ζ > 1, s1 and s2 are real and negative, distinct roots and when ζ = 1, s1 = s2 = – ωn repeated roots. If the poles are real, the system is overdamped.  When ζ < 1, s1 and s2 are complex conjugates roots. If the poles are complex, the system is underdamped.  If the poles consist of only an imaginary part and no real part (ζωn = 0), the poles are imaginary.  If the poles are imaginary, the system is undamped.  If either pole has positive real component, the system is unstable.

Zero- The zeros of a second order system are the values of  ‘s’ which make the numerator of the transfer function equal to zero.

Problem Description:

Formulation:

With the increasing amount of cars, traffic congestion has become an important issue, especially on highways. Several mathematical models like the car following model, the cellular automation model and the particle-hopping model have been developed to describe and subsequently, optimize traffic flow. However, a major hurdle in the path is the unpredictable nature of highway traffic, for example:

• No vehicle moves at a constant speed; an oscillatory behavior of speeds is seen
• Possibility of abrupt changes in speed of any vehicle at any time, presumably the leader
• Possibility of certain groups of vehicles moving slowly, i.e. the “gaper” block

Such unexpected changes can act against the smooth running of a simulation describing highway traffic flow. Therefore, this project focused on solving these problems by making customary modifications to the car following model.

Approach to Solution:
The follow-the-leader model by Bardzimashvili for single lane unidirectional traffic was modified from its original simulation shown below:

In order to compensate for the aforementioned issues with highway traffic, the following precautions were taken:

• Every vehicle will keep a user-decided relative distance from the vehicle it is following
• Consequently, although redundant, no vehicles will pass each other
• The reaction times of all vehicles will be in the “stable” range, described later on. It was found that a reaction time of 0.7s is assumed stable, which was applied to all vehicles

 The dynamics of highway traffic consist of multiple problems which must be considered as individual variables.

The following four models were comprised to evaluate the proposed conditions:
1. Relative Distance Model (RDM): A model wherein each vehicle keeps a relative distance from the vehicle it is following. Consequently, any deceleration in the leader would result in deceleration by the follower.
2.  Oscillatory Speeds Behavior Model (OSBM): A simulation built upon the RDM.  A sine wave was utilized to represent gradual changes in speed of the lead vehicle. 
3. Instantaneous Deceleration Model (IDM): Also used the RDM as a foundation. The lead vehicle experiences an instantaneous change in velocity hence an instantaneous deceleration. All vehicles reach a slower speed steady state which induces congestion that is followed by a recovery period.
4. Gaper Block Model (GBM): A model built upon the RDM, but in this case, consists of two leaders with a considerable difference in speed. The faster leader undergoes the same procedure as in the IDM. Consequently congestion occurs. The slower leader approaches the lead group of vehicles, as the latter resumes to original speed, the gap widens and becomes constant at steady state.

Development of the Model:

The leader-follower model outlined above relates the acceleration of a given car to the difference between the velocity of the car directly in front of the one in question.  From Bardzimashvilli the equation to describe the system is:

Using this representation λ represents a fixed value coefficient for the sensitivity of the driver to the changing conditions.  A higher value for λ would correspond to a more sensitive system in which a driver overcompensates leading to overshoot of the desired values.  The reaction time of a driver is represented by τ in output of the system.

This system requires that two properties be defined; λ and τ, which when combined will affect the stability of the traffic flow on a highway.  First the transfer function needs to be determined by taking the Laplace transfer of (Equ.6) treating the velocity of the forward car (x’n-1(t)) as an input and the velocity of the following car (x’n(t)) as an output.

Although the leader-follower model relates acceleration and velocity, the initial model does not include relative position and thus is only a first order function.  To find the poles of the system, the denominator is set equal to zero and solved using MATLAB (see Appendix B).
 

As with any system, if a pole lies within the right hand plane of a pole-zero plot the system will exhibit instability.  To determine the appropriate values of λ and τ to ensure stability, reaction time was fixed at 0.25s increments from 0 to 2s and different values of λ were applied to (Equ.14).  Due to the nature of Lambert’s W function some poles were complex, unacceptable without its conjugate, so the pole was taken as a magnitude of the real and imaginary parts.

As evidenced in both Figure 2 and Figure 3, the increasing sensitivity of the system leads to greater instability even for reaction times as small as 0.6s.  From Figure 3 it is easier to determine a relationship between the two parameters since there is a point around τ*λ = 0.5 where most curves cross the horizontal axis.  Therefore the definition to ensure stability of the leader-follower model is determined to be:

Human reaction time, modeled by τ, is something that can be easily determined by empirical data.  Thus λ is chosen as a function of the other since it is a determined property inherent to the system.  Based on study of human reaction time and assuming ideal conditions, τ = 0.70s .  From (Equ.16) this would require that λ < 0.714 for which a root locus is shown in Figure 4.

Simulation Results:

Model A – Relative Distance Model (RDM):

This model takes the Simulink model from Bardzimashvili and was altered to include the distance between a car and the car directly in front of it in the feedback loop1.  This adjustment to the feedback loop allows the cars to get within a predetermined distance of the car in front of it before it reducing speed to avoid crashing. 

The results of the simulation show what would be expected of a traffic situation with one lane and one lead car.  As shown in the graph of Speed vs. Time (see Figure 6), it can be seen that the lead car is set at its constant value and the following cars approach the speed of the lead car while maintaining a constant distance from each other. Table 2, below, reflects this nature by showing that the rise time for each subsequent car.  The system manifests that the secondary car will not reach the steady state until the car directly in front reaches the steady state.

The discontinuities are a result of the modification to the feedback loop.  The modification causes a deceleration if the distance between cars becomes closer than 5 meters.

As evidenced by Figure 7 and Table 3, the poles of the system are altered by changing the value of λ.  As the poles move farther from the origin, the settling time of the system, namely this car, decreases.  Unlike a second order system however, the rise time of the system also decreases since the slopes are related to the sensitivity of the system.  As drivers become more ‘sensitive’ they react more aggressively leading to steeper slopes and a faster response.

Model B – Oscillatory Speeds Behavior Model (OSBM):

This model is identical to the first model except that the lead car speed is a sine wave instead of a constant.  This model illustrates the oscillatory behavior of traffic which is a more realistic view of actual traffic.  The simulation shows that the following car speeds are also sinusoidal because the model makes them adjust their speed to stay behind the car in front.  It is also important to note that the relative distance between the cars is sinusoidal as well.  This effect can be seen in Figure 8 which shows the relative distance vs. time.  This can be explained by the reaction time of the people driving the cars.  If the following car had an instantaneous reaction the car in front, the relative distance would be the same.  Since this is not the case, the driver takes a certain amount of time to slow to the lead car’s speed thus resulting in a sinusoidal distance between cars.

Model C – Instantaneous Deceleration Model (IDM):

This model is also a slight modification of the first Simulink model.  It forces the lead car to instantaneously decelerate from a constant speed to a lower set speed after a steady state has been reached.  Then after a predetermined amount of time, instantaneously increases back to the original constant speed.  For this model to work correctly, it must use the same feedback modification which includes the limit on relative distance.  In theory this sudden drop in speed by the lead car will cause a sudden drop in relative distances with some cars over compensating (overshooting) before they reach a steady state (see Table 4. Percent Overshoot for IDM).  These theoretical results can be seen in the simulation plot of relative distance vs. time (see Figure 9).  The resulting velocity graph (see Figure 10) also shows how cars overshoot the desired speed after the sudden deceleration and eventually reach a steady state.  However, when the sudden increase occurs, the cars are less likely to overshoot because the system does not over reacts to the speed increase by the lead car.

Just as with the first model, as the poles move from the origin, the settling time of the car decreases (see Figure 11 and Table 5).  The rise/fall time also decreases, but in the case of the congested area as the rise time decreases, the overshoot increases dramatically.  This is due to the increased sensitivity of the driver who has reached steady state and is disturbed thereby causing overcompensation in the deceleration.

Model D – Gaper Block Model (GBM):

This Simulink model is a modification of the previous IDM model.  This model takes the third to last car of the group and makes it a “leader.” The car now is affected that is to say that is no longer affected by the car in front of it and goes at whichever constant speed it chooses.  This model fixes the car to be much lower than the lead car. This exemplifies the effects of a slow moving car on a single lane road and illustrates how it compares to the traffic ahead.  A defining result of this model can be seen in the relative distance vs. time graph (see Figure 12).

It can be seen that the last three cars (the constant slow car and its two followers) distance get increases further from the cars in front of them.  After 200 seconds the lead car instantaneously decelerates as in the previous model.  This brings the speed of the frontal cars to a slower speed which allows the following group of slower moving vehicles to gain distance on the first three cars.  However, since the front car eventually returns to its faster speed, the back three cars begin to fall farther behind again.

Future Work:

Although the finished model does make use of the relative distance between cars to affect vehicle behavior, the current method has been derived from a programming perspective.  Instead of Boolean logic, it would be better to represent the relative distance feedback loop as a continuous system with its own gain independent of the velocity feedback system (see Figure 13).  This enhances the modeling of the system and a transfer function could be derived.  The transfer function could be used in the model to determine the sensitivity of the system which keeps it stable and if empirical data was applied for sensitivity, an optimum distance could be found.
 

Additional work to the model itself could include direct control via a MATLAB m-file of the Simulink model.  By controlling the parameters from MATLAB, a more in-depth analysis can be performed automatically instead of manually altering values.

Other work would include making a congestion event continuous to better reflect real world conditions.  As it stands the model generates a discontinuity to force the lead car or posted speed limit to a lower value after a given position on the highway.  Although this is acceptable if the max velocity is treated as a speed limit, it is impractical if instead a car is dropping that fast.

To better simulate traffic conditions, additional work is needed to allow interaction between the cars.  A single lane representation with passing would prevent slowing of cars when compensating for change in speed.  This could then allow for the simulation of collisions; i.e. if relative distance becomes negative on a single lane road.  By stopping the two vehicles and requiring all remaining cars to change to a single lane model, the congestion simulation would better represent the two lane highways in the event of an accident.  Generating new vehicles and randomizing the initial velocities and positions of all vehicles involved would also move towards simulating real world conditions.  These may be better addressed by stochastic models such as a “random walk” with uniform random density or Poisson distributions.

The simulink models of the above discussed models are given below:

Please feel free to point out mistakes as well as comment.