col-line.c

无线通信的各种运动模型。适用于移动通信、无线传感器网络等领域。 包括：Random walk、random waypoint、random direction、boundless simulation

/******************************************************************************
*   File Name: col-line.c
*   Purpose: column mobility model (nodes move parallel to direction of travel)
*   Author: Jeff Boleng
*   Date Created:
*
*   Copyright (C) 2004  Toilers Research Group -- Colorado School of Mines
*
*   Please see COPYRIGHT.TXT and LICENSE.TXT for copyright and license
*   details.
*
*   Bug fixes:
*
*   Sept. 16th, 2004
*   - reported by Rick Martin
*   - Code fixed by Rick Martin
*   - Verified by Feng Sun
*   Fixed the maxX, maxY problem in ns2 when X destination value equals to
*   the maximum X value of the simulation range.
*
*   Edited 12 July 2006 by Jon Petty:  
*   Changed seed code to rand((int)time(NULL) + (int)getpid())
*
******************************************************************************/ 

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <unistd.h>

#define rand48

#define true  1
#define false 0
#define zero 0.000001
#define infinity HUGE_VAL

double startTime = 1000.0;

//double startTime = 0.0;
#define minX 0.00001
#define minY 0.00001

/*See bug fix Sept. 16th, 2004 */
#define ZERO 0.000000000001

double PiOverTwo;

double getRand()
{
  #ifdef rand48
	return drand48();
  #else
	return (double)rand()/(double)RAND_MAX;
  #endif
}

double *xLocRefPt, *yLocRefPt;
double *xDestRefPt, *yDestRefPt;
double minXlocal, maxXlocal, minYlocal, maxYlocal;
double nodeSep=0.0;
double maxX=0.0, maxY=0.0;
double newX, newY, dist, speed;
double *xLocNode, *yLocNode;
double *nextEventNode;
double *nextEventRefPt;
double *startEventRefPt;
double *speedRefPt;
char output;
int nodeIDstart = 0;

void shortMove(int which, double when)
{
	/* the group reference point is not done moving, so pick a new move for this node
	   relative to it's reference point's current location */
	minXlocal = xLocRefPt[which]-nodeSep;
	if (minXlocal < minX) minXlocal = minX;
	maxXlocal = xLocRefPt[which]+nodeSep;
	if (maxXlocal >= maxX) maxXlocal = maxX-ZERO;
	minYlocal = yLocRefPt[which]-nodeSep;
	if (minYlocal < minY) minYlocal = minY;
	maxYlocal = yLocRefPt[which]+nodeSep;
	if (maxYlocal >= maxY) maxYlocal = maxY-ZERO;

	newX = minXlocal + getRand()*(maxXlocal - minXlocal);
	newY = minYlocal + getRand()*(maxYlocal - minYlocal);
	if (newX < minX) newX = minX;
	if (newX >= maxX) newX = maxX-ZERO;
	if (newY < minY) newY = minY;
	if (newY >= maxY) newY = maxY-ZERO;

	/* move node's at twice the speed of the reference point? */
	/* speed = 2.0*speedRefPt[which]; */
	speed = speedRefPt[which];
	if (when != startTime)
	{
		if (output == 'N')
		{
			fprintf(stdout, "$ns_ at %.12f \"$node_(%d) setdest %.12f %.12f %.12f\" #shortMove\n",
			        nextEventNode[which], which+nodeIDstart, newX, newY, speed);
		} else if (output == 'G') {
			/* fprintf(stdout, "#ONE\n"); */
			fprintf(stdout, "%d %.10f %.12f %.12f #shortMove\n",
			        which+nodeIDstart, nextEventNode[which], newX, newY);
			/* fprintf(stdout, "%.12f %.12f # node %d at %.10f speed=%.10f\n", newX, newY,
			                 which+nodeIDstart, nextEventNode[which], speed); */
		}
	}

	dist = sqrt((newX-xLocNode[which])*(newX-xLocNode[which])+
	            (newY-yLocNode[which])*(newY-yLocNode[which]));
	xLocNode[which] = newX;
	yLocNode[which] = newY;
	nextEventNode[which] += dist/speed;

	/* be sure to set ref pt dest and ref pt loc correctly
	    - ref pt dest is final reference point destination
	    - ref pt loc is the future location of ref pt at the next event for node */
	if (when >= nextEventRefPt[which])
	{
		xLocRefPt[which] = xDestRefPt[which];
		yLocRefPt[which] = yDestRefPt[which];
	} else {
		double xDelta = xDestRefPt[which] - xLocRefPt[which];
		double yDelta = yDestRefPt[which] - yLocRefPt[which];
		double travelPercent = (nextEventNode[which] - startEventRefPt[which]) /
		                       (nextEventRefPt[which] - startEventRefPt[which]);
		xLocRefPt[which] += travelPercent*xDelta;
		yLocRefPt[which] += travelPercent*yDelta;
	}

	return;
}

int main(int argc, char *argv[])
{
	int g, n, i, mult;
	int numGroups=0;
	int nextNode=0;
	int nodesPerGroup=0;
	double xSep=0.0, ySep=0.0;
	double refPtSep=0.0;
	double endTime=0.0, lowest;
	double speedMean=0.0, speedDelta=0.0;
	double pauseMean=0.0, pauseDelta=0.0;
	double pauseTime = 0.0;
	int *movingNode;
	int *movingRefPt;
	double speedLow, pauseLow;
	double speedRange, pauseRange;
	double direction=0.0;

	PiOverTwo = acos(0.0);

	if ((argc == 13) || (argc == 14))
	{
		if (argc == 13)
		{
			nodeIDstart = 0;
		} else {
			nodeIDstart = atoi(argv[13]);
		}

		numGroups      = atoi(argv[1]);
		nodesPerGroup  = atoi(argv[2]);
		refPtSep       = atof(argv[3]);
		nodeSep        = atof(argv[4]);
		maxX           = atof(argv[5]);
		maxY           = atof(argv[6]);
		endTime        = atof(argv[7]);
		speedMean      = atof(argv[8]);
		speedDelta     = atof(argv[9]);
		pauseMean      = atof(argv[10]);
		pauseDelta     = atof(argv[11]);
		output         = argv[12][0];

		fprintf(stdout, "#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
		fprintf(stdout, "#\tnumGroups      = %6d\n", numGroups);
		fprintf(stdout, "#\tnodesPerGroup  = %6d\n", nodesPerGroup);
		fprintf(stdout, "#\trefPtSep       = %9.2f\n", refPtSep);
		fprintf(stdout, "#\tnodeSep        = %9.2f\n", nodeSep);
		fprintf(stdout, "#\tmaxX           = %9.2f\n", maxX);
		fprintf(stdout, "#\tmaxY           = %9.2f\n", maxY);
		fprintf(stdout, "#\tendTime        = %9.2f\n", endTime);
		fprintf(stdout, "#\tspeedMean      = %9.2f\n", speedMean);
		fprintf(stdout, "#\tspeedDelta     = %9.2f\n", speedDelta);
		fprintf(stdout, "#\tpauseMean      = %9.2f\n", pauseMean);
		fprintf(stdout, "#\tpauseDelta     = %9.2f\n", pauseDelta);
		fprintf(stdout, "#\toutput         = %6c\n", output);
		fprintf(stdout, "#\tnodeIDstart    = %6d\n", nodeIDstart);
		fprintf(stdout, "#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n");
	} else {
		fprintf(stdout, "Usage:  col-line <number of groups>\n");
		fprintf(stdout, "            <nodes per group>\n");
		fprintf(stdout, "            <ref. pt. separation>\n");
		fprintf(stdout, "            <node separation from ref. pt.>\n");
		fprintf(stdout, "            <max-x> <max-y> <end time>\n");
		fprintf(stdout, "            <speed mean> <speed delta>\n");
		fprintf(stdout, "            <pause time> <pause time delta>\n");
		fprintf(stdout, "            <'N' or 'G'>\n");
		fprintf(stdout, "            'N' implies NS2 mobility file\n");
		fprintf(stdout, "            'G' implies gnuplot path file\n");
		fprintf(stdout, "            [<node ID start> default 0]\n");
		return -1;
	}

	endTime += startTime;

	if (output == 'N')
	{
		fprintf(stdout, "# output format is NS2\n");
	} else if (output == 'G') {
		fprintf(stdout, "# output format is gnuplot\n");
		fprintf(stdout, "set xrange[0:%.12f]\n", maxX);
		fprintf(stdout, "set yrange[0:%.12f]\n", maxY);
		//    if (numGroups != 1)
		//    {
		//      fprintf(stderr, "Gnuplot output is only possible with one mobile group.\n");
		//      return -1;
		//    } else {
		fprintf(stdout, "set multiplot\n");
		fprintf(stdout, "plot \'-\' using 3:4 notitle with linespoints\n");
		//    }
	} else {
		fprintf(stderr, "Unknown output type requested\n");
		return -1;
	}

  #ifdef rand48
	srand48((int)time(NULL) + (int)getpid());
  #else
	srand((int)time(NULL) + (int)getpid());
  #endif
	speedLow = speedMean-speedDelta;
	pauseLow = pauseMean-pauseDelta;
	speedRange = 2*speedDelta;
	pauseRange = 2*pauseDelta;

	movingNode = (int*)malloc(sizeof(int)*numGroups*nodesPerGroup);
	xLocNode = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);
	yLocNode = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);
	nextEventNode = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);

	movingRefPt = (int*)malloc(sizeof(int)*numGroups*nodesPerGroup);
	speedRefPt = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);
	xLocRefPt = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);
	yLocRefPt = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);
	xDestRefPt = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);
	yDestRefPt = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);
	nextEventRefPt = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);
	startEventRefPt = (double*)malloc(sizeof(double)*numGroups*nodesPerGroup);

	fprintf(stdout, "#\tInitial positions:\n");
	fprintf(stdout, "#\t  (node initial positions are also initial reference point positions)\n");
	for (g=0; g<numGroups; g++)
	{
		int horizontal = (getRand()>=0.5)?true:false;
		fprintf(stdout,"#\tHorizontal is %s.\n", (horizontal)?"true":"false");
		//mult = (getRand()>=0.5)?-1:1;
		mult = 1;
		fprintf(stdout,"#\tMult is %d.\n", mult);
		/* node 0 in each group is also the group reference point */
		/* it can be placed in a totally random fashion */
		/* each other point in the group must be placed in reference to it */
		movingNode[g*nodesPerGroup] = movingRefPt[g*nodesPerGroup] = (getRand()>=0.5)?true:false;
		//movingNode[g*nodesPerGroup] = movingRefPt[g*nodesPerGroup] = false;
		xLocNode[g*nodesPerGroup] = xLocRefPt[g*nodesPerGroup] = getRand()*maxX;