freeway.cpp

These mobility generator tools are used to generate a rich set of mobility scenarios used to evalua

#include "freeway.h"
#include "map.h"
#include "node.h"

//global variable
int global_clock=0;

class Map mymap;
class Node *mynode;



//sort all nodes on the maps into several queues
void sort_initial(class Map *my_map, class Node *my_node)
{
	int i,j;
	int src_lane_id,src_phase_id;
	int pre=-1,suc=-1;
	float min_pre=10000.0,min_suc=10000.0; // min distance to pre/suc

	printf("N=%d\n",NUM_OF_NODE);

	for(i=0;i<NUM_OF_NODE;i++)
	{
		
		src_lane_id = my_node[i].src_lane; 
		src_phase_id = my_node[i].src_phase; 
		pre=-1;suc=-1;
		min_pre=10000.0;min_suc=10000.0;

		//if the lane is empty, insert the 1st one
		if(my_map->lane_array[src_lane_id].vehicle_head == NULL)
			my_map->link_initiate (src_lane_id,i);
		
		//else 
		else {
			for(j=0;j<i;j++)
			{	
				if( my_node[i].src_lane == my_node[j].src_lane &&
					my_node[i].src_phase >= my_node[j].src_phase &&
					//getmy_distance(my_node[i].src_x,my_node[i].src_y,my_node[j].src_x,my_node[j].src_x) < min_suc &&
					//getmy_sign(my_map->lane_array[src_lane_id].phase_array[src_phase_id].x0,my_map->lane_array[src_lane_id].phase_array[src_phase_id].x1,my_map->lane_array[src_lane_id].phase_array[src_phase_id].y0,my_map->lane_array[src_lane_id].phase_array[src_phase_id].y1) 
					//  == getmy_sign(my_node[j].src_x,my_node[i].src_x,my_node[j].src_y,my_node[i].src_y) 
					getmy_phase_dist1(my_node[i].src_phase,my_node[i].src_offset,my_node[j].src_phase,my_node[j].src_offset) < min_suc    ) 
				{
					suc = j; 
					min_suc = getmy_phase_dist1(my_node[i].src_phase,my_node[i].src_offset,my_node[j].src_phase,my_node[j].src_offset);
					//printf("i=%d,suc=%d,min_suc=%f\n",i,suc,min_suc);
				}

				if( my_node[i].src_lane == my_node[j].src_lane &&
					my_node[i].src_phase <= my_node[j].src_phase &&
					//getmy_distance(my_node[i].src_x,my_node[i].src_y,my_node[j].src_x,my_node[j].src_x) < min_pre &&
					//getmy_sign(my_map->lane_array[src_lane_id].phase_array[src_phase_id].x0,my_map->lane_array[src_lane_id].phase_array[src_phase_id].x1,my_map->lane_array[src_lane_id].phase_array[src_phase_id].y0,my_map->lane_array[src_lane_id].phase_array[src_phase_id].y1) 
					//  == getmy_sign(my_node[i].src_x,my_node[j].src_x,my_node[i].src_y,my_node[j].src_y) ) 
					getmy_phase_dist2(my_node[i].src_phase,my_node[i].src_offset,my_node[j].src_phase,my_node[j].src_offset) < min_pre )
				{
					pre = j; 
					min_pre = getmy_phase_dist2(my_node[i].src_phase,my_node[i].src_offset,my_node[j].src_phase,my_node[j].src_offset);
					//printf("i=%d,pre=%d,min_pre=%f\n",i,pre,min_pre);
				}
			}//for j
			//printf("ID=%d's pre=%d, suc=%d\n",i,pre,suc);
			my_map->link_insert(src_lane_id,pre,suc,i);
		}//if-else

		//printf("node=%d on lane=%d: ",i,src_lane_id);
		//my_map->show_linklist(src_lane_id); 

	}//for i

	//printf("INITIATION: queue is like that\n");
	//for(i=0;i<my_map->get_lane_num();i++)
	//	my_map->show_linklist(i);
}


float speed_check(int i, int clock, class Map *my_map, class Node *my_node)
{
	int predecessor,successor;
	float distance1,distance2,return_value;

	predecessor = my_map->predecessor(i);
	successor =  my_map->successor(i);
	if(predecessor!=-1)
		distance1=getmy_distance(my_node[i].x_array[clock],my_node[i].y_array[clock],my_node[predecessor].x_array[clock],my_node[predecessor].y_array[clock]); 
	if(successor!=-1)
		distance2=getmy_distance(my_node[i].x_array[clock],my_node[i].y_array[clock],my_node[successor].x_array[clock],my_node[successor].y_array[clock]); 
	
	//printf("i=%d's predecessor is %d, successor=%d\n",i,predecessor,successor);
	//printf("dist1=%f,dist2=%f\n",distance1,distance2);

	if(predecessor == -1 && successor!= -1 && distance2 >= 40.0)
		return_value = -1.0;
	else if( predecessor != -1 && distance1 <= 40.0 )
		return_value = my_node[predecessor].speed_array[clock] - ACCELERATION*0.5; 
	else if( predecessor != -1 && successor!= -1 && distance1 >100.0 && distance2< 40.0 )
		return_value = my_node[i].speed_array[clock]+ACCELERATION; 
	else if(predecessor == -1 && successor!= -1 && distance2<40.0)
		return_value = my_node[i].speed_array[clock]+ACCELERATION; 
	else 
		return_value = -1;

	//printf("value=%f\n",return_value);
	return return_value;
}





//main function
void main()
{
	int m,n;
	int i,j,k;
	float req_speed;
	FILE *fp;
	int input_d;
	float input_f;
	char map_name[20],trace_name[20];


	printf("*********************************************************\n");
	printf("*Welcome to the Freeway Mobility Generator by agroup@USC*\n");
	printf("*********************************************************\n\n");

	printf("input Number of Node:\n");
	scanf("%d",&input_d);
	NUM_OF_NODE = input_d;

	printf("input the Acceleration Speed:\n");
	scanf("%f",&input_f);
	ACCELERATION = input_f;

	printf("input the Filename of the map:\n");
	scanf("%s", map_name);

	printf("input the Filename of the Trace Output File:\n");
	scanf("%s", trace_name);

	mynode = new class Node[NUM_OF_NODE];

	mymap.map_read(map_name);
	fp = fopen(trace_name,"w");
	if(fp == NULL)	
	{	printf("Error opening output file!\n");
		exit(-1);	}


	for(i=0;i<100;i++)
			rand();

	mymap.map_read(map_name);
	
	fp = fopen(trace_name,"w");
	if(fp == NULL)	
	{	printf("Error opening output file!\n");
		exit(1);	
	}

	for(i=0;i<NUM_OF_NODE;i++)
		{
			for(n=0;n<100;n++)
				rand();
			mynode[i].initialize(i,&mymap);
			//mynode[i].show_trace (0);
		}
	sort_initial(&mymap,mynode);

	for(i=0;i<NUM_OF_NODE;i++)
		mynode[i].save_file(fp,0,0);

	
	for(i=1;i<SIMULATION_DURATION;i++)
		for(j=0;j<NUM_OF_NODE;j++)
			{
				rand();
				global_clock=i;
			
				req_speed = speed_check(j,global_clock-1,&mymap,mynode);
				mynode[j].update(&mymap,global_clock,req_speed);
				//mynode[j].show_trace(global_clock);
			}


	for(k=0; k<SIMULATION_DURATION;k++)
		for(i=0;i<NUM_OF_NODE;i++)
			for(j=i+1;j<NUM_OF_NODE;j++)
				if( getmy_distance(mynode[i].x_array[k],mynode[i].y_array[k],
					mynode[j].x_array[k],mynode[j].y_array[k]) < 0.01 ) 
				{
					//printf("TOO close: t=%d, i=%d <%f,%f>, j=%d <%f,%f>\n",
					//	k,i,mynode[i].x_array[k],mynode[i].y_array[k],
					//	j,mynode[j].x_array[k],mynode[j].y_array[k]);
					if( mynode[i].y_array[k] >= mynode[j].y_array[k] )
						mynode[i].y_array[k] += 0.2;
					else if ( mynode[i].y_array[k] < mynode[j].y_array[k] )
						mynode[j].y_array[k] += 0.2;
				}

	for(k=0; k<SIMULATION_DURATION;k++)
		for(i=0;i<NUM_OF_NODE;i++)
			for(j=i+1;j<NUM_OF_NODE;j++)
				if( getmy_distance(mynode[i].x_array[k],mynode[i].y_array[k],
					mynode[j].x_array[k],mynode[j].y_array[k]) < 0.01 ) 
				{
					//printf("STILL TOO close: t=%d, i=%d <%f,%f>, j=%d <%f,%f>\n",
					//	k,i,mynode[i].x_array[k],mynode[i].y_array[k],
					//	j,mynode[j].x_array[k],mynode[j].y_array[k]);
				}


	for(j=SIMULATION_DURATION-1;j>=0;j--)
		for(i=0;i<NUM_OF_NODE;i++)
			mynode[i].save_file(fp,1,j);

	fclose(fp);	
	delete [] mynode;

}