rpgm.c

Service Location Protocol

/******************************************************************************
*   File Name: rpgm.c
*   Purpose: Reference Point Group Mobility Model (RPGM)
*   Author: Jeff Boleng
*   Date Created: some time in the spring of 2002
*
*   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 Ricky Martin
*   - Code fixed by Ricky 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.
*
******************************************************************************/ 

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

#define rand48

#define true  1
#define false 0

/* 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 getRand()
{
  #ifdef rand48
    return drand48();
  #else
    return (double)rand()/(double)RAND_MAX;
  #endif
}

int main(int argc, char *argv[])
{
  int g, n, i;
  int numGroups=0;
  int nextNode=0;
  int nodesPerGroup=0;
  double refPtSep=0.0, nodeSep=0.0;
  double maxX=0.0, maxY=0.0;
  double endTime=0.0, lowest;
  double speedMean=0.0, speedDelta=0.0;
  double pauseMean=0.0, pauseDelta=0.0;
  int *movingNode;
  double *nextEventNode;
  double *nextEventRefPt;
  double *startEventRefPt;
  double *xLocNode, *yLocNode;
  int *movingRefPt;
  double *speedRefPt;
  double *xLocRefPt, *yLocRefPt;
  double *xDestRefPt, *yDestRefPt;
  double newX, newY, dist;
  double speedLow, pauseLow;
  double speedRange, pauseRange;
  char output;
  double minXlocal, maxXlocal, minYlocal, maxYlocal;
  double minXdest, maxXdest, minYdest, maxYdest;
  double speed;
  int nodeIDstart = 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:  rpgm <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));
  #else
    srand((int)time(NULL));
  #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++)
  { 
    /* 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;
    xLocNode[g*nodesPerGroup] = xLocRefPt[g*nodesPerGroup] = getRand()*maxX;
    yLocNode[g*nodesPerGroup] = yLocRefPt[g*nodesPerGroup] = getRand()*maxY;
    xDestRefPt[g*nodesPerGroup] = getRand()*maxX;
    yDestRefPt[g*nodesPerGroup] = getRand()*maxY;
    nextEventNode[g*nodesPerGroup] = nextEventRefPt[g*nodesPerGroup] = startEventRefPt[g*nodesPerGroup] = startTime;
    speedRefPt[g*nodesPerGroup] = startTime;

    minXlocal = xLocRefPt[g*nodesPerGroup]-refPtSep;
    if (minXlocal < minX) minXlocal = minX;
    maxXlocal = xLocRefPt[g*nodesPerGroup]+refPtSep;
    if (maxXlocal >= maxX) maxXlocal = maxX-ZERO;
    minYlocal = yLocRefPt[g*nodesPerGroup]-refPtSep;
    if (minYlocal < minY) minYlocal = minY;
    maxYlocal = yLocRefPt[g*nodesPerGroup]+refPtSep;
    if (maxYlocal >= maxY) maxYlocal = maxY-ZERO;

    minXdest = xDestRefPt[g*nodesPerGroup]-refPtSep;
    if (minXdest < minX) minXdest = minX;
    maxXdest = xDestRefPt[g*nodesPerGroup]+refPtSep;
    if (maxXdest >= maxX) maxXdest = maxX-ZERO;
    minYdest = yDestRefPt[g*nodesPerGroup]-refPtSep;
    if (minYdest < minY) minYdest = minY;
    maxYdest = yDestRefPt[g*nodesPerGroup]+refPtSep;
    if (maxYdest >= maxY) maxYdest = maxY-ZERO;

    for (n=1; n<nodesPerGroup; n++)
    {
      /* movingNode[g*nodesPerGroup+n] = movingRefPt[g*nodesPerGroup+n] = (getRand()>=0.5)?true:false; */
      /* all group member nodes have the same moving status as the group reference point (node 0) */
      movingNode[g*nodesPerGroup+n] = movingRefPt[g*nodesPerGroup+n] = movingRefPt[g*nodesPerGroup];
      xLocNode[g*nodesPerGroup+n] = xLocRefPt[g*nodesPerGroup+n] = minXlocal + getRand()*(maxXlocal - minXlocal);
      yLocNode[g*nodesPerGroup+n] = yLocRefPt[g*nodesPerGroup+n] = minYlocal + getRand()*(maxYlocal - minYlocal);
      xDestRefPt[g*nodesPerGroup+n] = minXdest + getRand()*(maxXdest - minXdest);
      yDestRefPt[g*nodesPerGroup+n] = minYdest + getRand()*(maxYdest - minYdest);
      nextEventNode[g*nodesPerGroup+n] = nextEventRefPt[g*nodesPerGroup+n] = startEventRefPt[g*nodesPerGroup+n] = startTime;
      speedRefPt[g*nodesPerGroup+n] = startTime;
    }
  }

  for (g=0; g<numGroups; g++)
  { 
    fprintf(stdout, "#\t### Group %d ###\n", g);
    fprintf(stdout, "#\tGroup %d:  %s moving\n", g, ((movingNode[g*nodesPerGroup+n])?"is not":"is"));
    for (n=0; n<nodesPerGroup; n++)
    {
      /* fprintf(stdout, "#\t(group,node) (%d,%d):  %s moving\n", g, n, ((movingNode[g*nodesPerGroup+n])?"is not":"is")); */
      if (output == 'N')
      {
        fprintf(stdout, "$node_(%d) set X_ %.12f\n", g*nodesPerGroup+n+nodeIDstart, xLocNode[g*nodesPerGroup+n]);
        fprintf(stdout, "$node_(%d) set Y_ %.12f\n", g*nodesPerGroup+n+nodeIDstart, yLocNode[g*nodesPerGroup+n]);
        fprintf(stdout, "$node_(%d) set Z_ %.12f\n", g*nodesPerGroup+n+nodeIDstart, startTime);
      } else if (output == 'G') {
        /* xLocNode[g*nodesPerGroup+n] = maxX/2.0; */
        /* yLocNode[g*nodesPerGroup+n] = maxY/2.0; */
        fprintf(stdout, "%d %.10f %.12f %.12f\n", g*nodesPerGroup+n+nodeIDstart, startTime,
                         xLocNode[g*nodesPerGroup+n], yLocNode[g*nodesPerGroup+n]);
      }
    }
    if (output == 'N')
    {
      fprintf(stdout, "\n");
    }
  }