manhattangrid.java

能在 ns-2 下模拟出一个使用 swarm 算法通讯的网络

/*******************************************************************************
 ** BonnMotion - a mobility scenario generation and analysis tool             **
 ** Copyright (C) 2002, 2003 University of Bonn                               **
 **                                                                           **
 ** This program is free software; you can redistribute it and/or modify      **
 ** it under the terms of the GNU General Public License as published by      **
 ** the Free Software Foundation; either version 2 of the License, or         **
 ** (at your option) any later version.                                       **
 **                                                                           **
 ** This program is distributed in the hope that it will be useful,           **
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of            **
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             **
 ** GNU General Public License for more details.                              **
 **                                                                           **
 ** You should have received a copy of the GNU General Public License         **
 ** along with this program; if not, write to the Free Software               **
 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA **
 *******************************************************************************/

package edu.bonn.cs.iv.bonnmotion.models;

import java.io.*;
import java.util.*;

import edu.bonn.cs.iv.bonnmotion.*;

/** Manhattan Grid mobility scenario. */

public class ManhattanGrid extends Scenario {

	private static final String MODEL_NAME = "ManhattanGrid";

	/** Number of blocks on x-axis. */
	protected int xblocks = 10;
	/** Number of blocks on y-axis. */
	protected int yblocks = 10;

	/** Distance interval in which to possibly update the mobile's speed [m]. */
	protected double updateDist = 5.0;
	/** Probability for the mobile to turn at a crossing. */
	protected double turnProb = 0.5;
	/** Probability for the mobile to change its speed (every updateDist m). */
	protected double speedChangeProb = 0.2;
	/** Mobile's mean speed [m/s]. */
	protected double meanSpeed = 1.0;
	/** Mobile's minimum speed [m/s]. */
	protected double minSpeed = 0.5;
	/** Standard deviation of normally distributed random speed [m/s]. */
	protected double speedStdDev = 0.2;
	/** Probability for the mobile to pause (every updateDist m), given it does not change it's speed. */
	protected double pauseProb = 0.0;
	/** Maximum pause time [s]. */
	protected double maxPause = 120.0;

	/** Size of a block on x-axis, calculated from xblocks. */
	protected double xdim;
	/** Size of a block on y-axis, calculated from yblocks. */
	protected double ydim;

	public ManhattanGrid(
		int nodes,
		double x,
		double y,
		double duration,
		double ignore,
		long randomSeed,
		int xblocks,
		int yblocks,
		double updateDist,
		double turnProb,
		double speedChangeProb,
		double meanSpeed,
		double minSpeed,
		double speedStdDev,
		double pauseProb,
		double maxPause) {
		super(nodes, x, y, duration, ignore, randomSeed);
		this.xblocks = xblocks;
		this.yblocks = yblocks;
		this.updateDist = updateDist;
		this.turnProb = turnProb;
		this.speedChangeProb = speedChangeProb;
		this.meanSpeed = meanSpeed;
		this.minSpeed = minSpeed;
		this.speedStdDev = speedStdDev;
		this.pauseProb = pauseProb;
		this.maxPause = maxPause;
		generate();
	}

	public ManhattanGrid( String args[] ) {
		go( args );
	}

	public void go(String[] args) {
		super.go(args);
		generate();
	}

	public void generate() {
		preGeneration();

		xdim = x / (double) xblocks;
		ydim = y / (double) yblocks;

		pauseProb += speedChangeProb;

		for (int i = 0; i < node.length; i++) {
			//			System.out.println("node " + (i + 1) + "/" + node.length);
			node[i] = new MobileNode();
			double t = 0.0, st = 0.0;
			Position src = new Position(0.0, 0.0);
//			System.out.println("add waypoint (1) " + src + " at 0.0");
			if (!node[i].add(0.0, src)) {
				System.out.println("ManhattanGrid.<init>: error while adding node movement (1)");
				System.exit(0);
			}
			Position pos = src;
			int dir = 0; // 0=up, 1=down, 2=left, 3=right
			double griddist = ydim;
			double speed = meanSpeed;
			double dist = updateDist;
			while (t < duration) {
				//				System.out.println("griddist=" + griddist);
				Position dst = getNewPos(pos, dist, dir);
				/*				System.out.println("t=" + t + " pos=" + pos + " dist=" + dist + " dst=" + dst);
								if (griddist <= dist)
									System.out.println("Gridpoint reached: " + alignPos(getNewPos(pos, griddist, dir))); */
				if (outOfBounds(dst)
					|| ((griddist <= dist) && (randomNextDouble() < turnProb))) { // turn
					dist -= griddist;
					t += griddist / speed;
					dst = alignPos(getNewPos(pos, griddist, dir));
					if (!src.equals(dst)) {
						// this is of concern when xdim or ydim are multiple of updateDist
//						System.out.println("add waypoint (2) " + dst + " at " + t);
						if (!node[i].add(t, dst))
							if (!nodeAddErrorHandler(i, t, dst)) {
								System.out.println(
									"ManhattanGrid.<init>: error while adding node movement (2)");
								System.exit(0);
							}
						src = dst;
					}
					pos = dst;
					st = t;
					if (dir < 2)
						if (pos.x > 0.0)
							if (pos.x < x)
								dir = (int) (randomNextDouble() * 2) + 2;
							else
								dir = 3;
						else
							dir = 2;
					else if (pos.y > 0.0)
						if (pos.y < y)
							dir = (int) (randomNextDouble() * 2);
						else
							dir = 1;
					else
						dir = 0;
					if (dir < 2)
						griddist = ydim;
					else
						griddist = xdim;
					//					System.out.println("Newdir: " + dir);
				} else {
					t += dist / speed;
					pos = dst;
					griddist -= dist;
					dist = updateDist;
					if (griddist < 0.0)
						if (dir < 2)
							griddist += ydim;
						else
							griddist += xdim;
					double rnd = randomNextDouble();
					if (rnd < pauseProb) {
						if (!src.equals(dst)) {
							// this is of concern when xdim or ydim are multiple of updateDist
//							System.out.println("add waypoint (3) " + dst + " at " + t);
							if (!node[i].add(t, dst))
								if (!nodeAddErrorHandler(i, t, dst)) {
									System.out.println(
										"ManhattanGrid.<init>: error while adding node movement (3)");
									System.exit(0);
								}
							src = dst;
						}
						if (rnd < speedChangeProb)
							st = t;
						else {
							st = t + randomNextDouble() * maxPause;
							t = st;
						}
						speed = (randomNextGaussian() * speedStdDev) + meanSpeed;
						if (speed < minSpeed)
							speed = minSpeed;
						//						System.out.println("update speed to " + speed);
					}
				}
			}
			if (st < duration) {
//				System.out.println("add waypoint (4) " + getNewPos(src, src.distance(pos) * (duration - st) / (t - st), dir) + " at " + duration);
				if (!node[i]
					.add(
						duration,
						getNewPos(src, src.distance(pos) * (duration - st) / (t - st), dir))) {
					System.out.println(
						"ManhattanGrid.<init>: error while adding node movement (4)");
					System.exit(0);
				}
			}
		}
		postGeneration();
	}

	protected boolean parseArg(String key, String value) {
		if (key.equals("model")) {
			if (!value.equals(MODEL_NAME)) {
				System.out.println("wrong model " + value);
				System.exit(-1);
			}
			return true;
		} else if (key.equals("xblocks")) {
			xblocks = Integer.parseInt(value);
			return true;
		} else if (key.equals("yblocks")) {
			yblocks = Integer.parseInt(value);
			return true;
		} else if (key.equals("updateDist")) {
			updateDist = Double.parseDouble(value);
			return true;
		} else if (key.equals("turnProb")) {
			turnProb = Double.parseDouble(value);
			return true;
		} else if (key.equals("speedChangeProb")) {
			speedChangeProb = Double.parseDouble(value);
			return true;
		} else if (key.equals("minSpeed")) {
			minSpeed = Double.parseDouble(value);
			return true;
		} else if (key.equals("meanSpeed")) {
			meanSpeed = Double.parseDouble(value);
			return true;
		} else if (key.equals("speedStdDev")) {
			speedStdDev = Double.parseDouble(value);
			return true;
		} else if (key.equals("pauseProb")) {
			pauseProb = Double.parseDouble(value);
			return true;
		} else if (key.equals("maxPause")) {
			maxPause = Double.parseDouble(value);
			return true;
		} else if (key.equals("ignore")) {
			ignore = Double.parseDouble(value);
			return true;
		} else if (key.equals("randomSeed")) {
			randomSeed = Long.parseLong(value);
			return true;
		} else
			return super.parseArg(key, value);
	}

	public boolean outOfBounds(Position pos) {
		return ((pos.x < 0.0) || (pos.y < 0.0) || (pos.x > x) || (pos.y > y));
		//		 || ((pos.x == 0.0) && (pos.y == 0.0)) || ((pos.x == x) && (pos.y == y)) || ((pos.x == x) && (pos.y == 0.0)) || ((pos.x == 0.0) && (pos.y == y)));
	}

	public Position alignPos(Position pos) {
		return new Position(
			(double) ((int) (pos.x / xdim + 0.5)) * xdim,
			(double) ((int) (pos.y / ydim + 0.5)) * ydim);
	}

	public Position getNewPos(Position src, double dist, int dir) {
		switch (dir) {
			case 0 :
				return new Position(src.x, src.y + dist);
			case 1 :
				return new Position(src.x, src.y - dist);
			case 2 :
				return new Position(src.x + dist, src.y);
			case 3 :
				return new Position(src.x - dist, src.y);
			default :
				return null;
		}
	}

	public boolean nodeAddErrorHandler(int i, double t, Position dst) {
		Waypoint last = node[i].lastElement();
		double distance = Math.abs(dst.x - last.pos.x + dst.y - last.pos.y);
		if ((t == last.time) && (distance < 0.1)) {
			node[i].removeLastElement();
			if (node[i].add(t, dst))
				return true;
		}
		System.out.println("ManhattanGrid.<init>: error while adding node movement");
		return false;
	}

	public void write(String _name) throws FileNotFoundException, IOException {
		String[] p = new String[11];
		p[0] = "model=" + MODEL_NAME;
		p[1] = "xblocks=" + xblocks;
		p[2] = "yblocks=" + yblocks;
		p[3] = "updateDist=" + updateDist;
		p[4] = "turnProb=" + turnProb;
		p[5] = "speedChangeProb=" + speedChangeProb;
		p[6] = "minSpeed=" + minSpeed;
		p[7] = "meanSpeed=" + meanSpeed;
		p[8] = "speedStdDev=" + speedStdDev;
		// hier muss speedChangeProb abgezogen werden, da es in go
		// nach parseArgs aufaddiert wird.
		p[9] = "pauseProb=" + (pauseProb - speedChangeProb);
		p[10] = "maxPause=" + maxPause;
		super.write(_name, p);
	}

	protected boolean parseArg(char key, String val) {
		switch (key) {
			case 'c' :
				speedChangeProb = Double.parseDouble(val);
				return true;
			case 'e' :
				minSpeed = Double.parseDouble(val);
				return true;
			case 'o' :
				maxPause = Double.parseDouble(val);
				return true;
			case 'p' :
				pauseProb = Double.parseDouble(val);
				return true;
			case 'q' :
				updateDist = Double.parseDouble(val);
				return true;
			case 'm' :
				meanSpeed = Double.parseDouble(val);
				return true;
			case 's' :
				speedStdDev = Double.parseDouble(val);
				return true;
			case 't' :
				turnProb = Double.parseDouble(val);
				return true;
			case 'u' :
				xblocks = Integer.parseInt(val);
				return true;
			case 'v' :
				yblocks = Integer.parseInt(val);
				return true;
			default :
				return super.parseArg(key, val);
		}
	}

	public static void printHelp() {
		Scenario.printHelp();
		System.out.println( MODEL_NAME + ":" );
		System.out.println("\t-c <speed change probability>");
		System.out.println("\t-e <min. speed>");
		System.out.println("\t-m <mean speed>");
		System.out.println("\t-o <max. pause>");
		System.out.println("\t-p <pause probability>");
		System.out.println("\t-q <update distance>");
		System.out.println("\t-s <speed standard deviation>");
		System.out.println("\t-t <turn probability>");
		System.out.println("\t-u <no. of blocks along x-axis>");
		System.out.println("\t-v <no. of blocks along y-axis>");
	}
}