base_corner.c

This code was used to produce simulation results described in: Using Directional Antennas to Pre

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define X_RANGE 500		/* The X Range of Terrain Area */
#define Y_RANGE 500		/* The Y Range of Treeain Area */
#define NODE_NUM 253		/* The number of sensor nodes */
#define RADIO_RANGE 40		/* The transmission range of omni antenna */
#define DIRECTIONAL_RANGE  72   /* The transmission range of directional antenna */
#define ITERATION 5		/* simulation times */
#define PI 3.14159265


struct NODE
{
    float x;			/* the x pixel of node*/		
    float y;			/* the y pixel of node */
    int id;			/* the ID of node */
} node[NODE_NUM];

/* This function defines the distance from node n1 to node n2 */
float distance (struct NODE n1, struct NODE n2);

int main()
{
       	
    int i, j, k, pix;
    int iteration;
  
    int node_num;			/* the number of nodes */
    int total_pairs, affected_pairs;
    float affected_ratio, avg_affected_ratio;
    float density, directional_density;
    
     FILE *fp;
    
    int d1[NODE_NUM][NODE_NUM];
    int d2[NODE_NUM][NODE_NUM];
    int edge[NODE_NUM][NODE_NUM];
    
    fp = fopen("base_corner.out", "w");
    


for (pix = 0; pix <= 500; pix += 25) {
	
    /* initilize */
    density = PI*RADIO_RANGE*RADIO_RANGE*NODE_NUM/X_RANGE/Y_RANGE;
    directional_density = PI*DIRECTIONAL_RANGE*DIRECTIONAL_RANGE*NODE_NUM/X_RANGE/Y_RANGE;
    printf("begin simulation for endpoint = [%d, %d]\n", pix, pix);
    printf("network density is %.2f, directional network density is %.2f\n", density, directional_density);
    
    avg_affected_ratio = 0;

    for (iteration = 0; iteration < ITERATION; iteration++) {   
    	
    	node_num = NODE_NUM - 3; 
	
	printf("start iteration %d......\n", iteration + 1);
	    
	/* initilize the position of randomly distributed nodes */
        for ( i = 0; i < node_num; i++) {
            node[i].x = (float)X_RANGE * rand() / RAND_MAX;
	    node[i].y = (float)Y_RANGE * rand() / RAND_MAX;
	    node[i].id = i;
	     
        }	
	
	/* index: [node_num] is base station, [node_num+1] is one wormhole end, [node_num+2] is another wormhole end */  
	node[node_num].x = 0;
	node[node_num].y = 0;
	node[node_num].id = node_num;
	node[node_num+1].x = (float)DIRECTIONAL_RANGE * rand() / RAND_MAX;
	node[node_num+1].y = (float)DIRECTIONAL_RANGE * rand() / RAND_MAX;
	node[node_num+1].id = node_num + 1;
	node[node_num+2].x = pix;
	node[node_num+2].y = pix;
	node[node_num+2].id = node_num + 2;
	node_num += 3;  
    
    	/* initilize the neighbor list and directional neighbor list of nodes */
    	for ( i = 0; i < node_num; i++) 
	    for ( j = i; j < node_num; j++) { 
		if (i == j) 
		    edge[i][j] = 0;
		else if ( (j == node_num - 2) || (j == node_num - 1)) {
		    edge[i][j] = 10000;
		    edge[j][i] = 10000;
		}
		else if ( distance(node[i], node[j]) < DIRECTIONAL_RANGE ) {
		    edge[i][j] = 1;
		    edge[j][i] = 1;
		}
		else {
		    edge[i][j] = 10000;
		    edge[j][i] = 10000;
		}
		d1[i][j] = edge[i][j];
		d1[j][i] = edge[j][i];
		d2[i][j] = edge[i][j];
		d2[j][i] = edge[j][i];
		
	    }
	    
	
	
	for (k = 0; k < node_num - 2; k++)
	    for (i = 0; i < node_num - 2; i++)
	        for (j = 0; j < node_num - 2; j++)
	            if ( (d1[i][k] + d1[k][j]) < d1[i][j]) {
	                d1[i][j] = d1[i][k] + d1[k][j];
	                d2[i][j] = d1[i][j];
	            }
	 
	 //d2[node_num-2][node_num-1] = -1;
	 //d2[node_num-1][node_num-2] = -1;
	 
	 for (i = 0; i < node_num - 2; i++) 
	     if ( distance(node[node_num-1], node[i]) < DIRECTIONAL_RANGE ) 
	     	  for (j = 0; j < node_num - 2; j++)
	     	      if (distance(node[node_num-2], node[j]) < DIRECTIONAL_RANGE) 
	     	      	 for (k = 0; k < node_num - 2; k++) {
	     	      	     if ( (d2[k][i] + d2[j][node_num-3]+1) < d2[k][node_num-3])
	     	      	         d2[k][node_num-3] = d2[node_num-3][k] = d2[k][i] + d2[j][node_num-3]+1;
	     	      	     if ( (d2[k][j] + d2[i][node_num-3]+1) < d2[k][node_num-3])
	     	      	     	d2[k][node_num-3] = d2[node_num-3][k] = d2[k][j] + d2[i][node_num-3]+1;
	     	      	 }
	     	      	  
	           
	           
	 total_pairs = node_num -3;  
	 affected_pairs = 0;
	 for (i = 0; i < node_num - 3; i++)
	          if (d2[node_num-3][i] < d1[node_num-3][i])
	              affected_pairs++;
	 
	 affected_ratio = (float)affected_pairs / total_pairs;
	 printf("in iteration %d (wormhole endpoint = [%d, %d]), the ratio is %.2f%%\n", iteration+1, pix, pix, affected_ratio * 100);
	 avg_affected_ratio += affected_ratio / ITERATION;
	 
			
    }  
    	
    fprintf(fp, "%d\t%.4f\n", pix, avg_affected_ratio);
    printf("the average ratio is %.2f%%\n\n", avg_affected_ratio * 100);
	
        
}
//fclose(fp);

    
    exit(0);
}

/* This function defines the distance from node n1 to node n2 */
float distance (struct NODE n1, struct NODE n2)
{
    return sqrt((n1.x - n2.x) * (n1.x - n2.x) + (n1.y - n2.y) * (n1.y - n2.y));
}