public interface CommunityDetectionEngine
{
	/**
	 * Returns the set of nodes in the local Community.
	 *  
	 * @return Set of hosts in the local community
	 */
	public Set<DTNHost> getLocalCommunity();
}

public DistributedBubbleRap(Settings s)//构造函数
{
    //COMMUNITY_ALG_SETTING = "communityDetectAlg"
    if(s.contains(COMMUNITY_ALG_SETTING))
        this.community = (CommunityDetection) 
  s.createIntializedObject(s.getSetting(COMMUNITY_ALG_SETTING));
    else
        this.community = new SimpleCommunityDetection(s);//最简单的计算community 的算法
	//CENTRALITY_ALG_SETTING = "centralityAlg"
    if(s.contains(CENTRALITY_ALG_SETTING))
        this.centrality = (Centrality) 
        s.createIntializedObject(s.getSetting(CENTRALITY_ALG_SETTING));
    else
        this.centrality = new SWindowCentrality(s);//最简单的计算centrality的算法
}

public void doExchangeForNewConnection(Connection con, DTNHost peer)
{
    // 开始计时这个新连接的持续时间，并通知社区检测对象新连接已经形成
    DTNHost myHost = con.getOtherNode(peer);
    DistributedBubbleRap de = this.getOtherDecisionEngine(peer);//获得con的另一个router

    this.startTimestamps.put(peer, SimClock.getTime());//记录开始时间
    de.startTimestamps.put(myHost, SimClock.getTime());

    this.community.newConnection(myHost, peer, de.community);//调用newConnection来通知连接已经形成
}

public void connectionDown(DTNHost thisHost, DTNHost peer)
{
    double time = startTimestamps.get(peer);
    double etime = SimClock.getTime();

    // Find or create the connection history list
    List<Duration> history;
    if(!connHistory.containsKey(peer))//如果不包含该节点的历史
    {
        history = new LinkedList<Duration>();
        connHistory.put(peer, history);
    }
    else
        history = connHistory.get(peer);

    // add this connection to the list
    if(etime - time > 0)
        history.add(new Duration(time, etime));

    CommunityDetection peerCD = this.getOtherDecisionEngine(peer).community;

    // inform the community detection object that a connection was lost.
    // The object might need the whole connection history at this point.
    community.connectionLost(thisHost, peer, peerCD, history);

    startTimestamps.remove(peer);
}

public boolean shouldSendMessageToHost(Message m, DTNHost otherHost)//转发
{
    if(m.getTo() == otherHost) return true; //如果不是当前结点，而是连接到的节点，那么转发

    DTNHost dest = m.getTo();//获取目的host
    DistributedBubbleRap de = getOtherDecisionEngine(otherHost);//得到邻接的router

    // 判断这两个community中哪个有该目的host
    boolean peerInCommunity = de.commumesWithHost(dest);
    boolean meInCommunity = this.commumesWithHost(dest);

    if(peerInCommunity && !meInCommunity) // 如果在peer中，那么转发
        return true;
    else if(!peerInCommunity && meInCommunity) // 只在当前community中，则不转发
        return false;
    else if(peerInCommunity) // 如果都在
    {
        if(de.getLocalCentrality() > this.getLocalCentrality())//根据中心度的大小进行判断(local)
            return true;
        else
            return false;
    }
    // Neither in local community, forward to more globally central node
    else if(de.getGlobalCentrality() > this.getGlobalCentrality())//如果都不在，则根据全局中心度大小判断
        return true;

    return false;
}

public void newConnection(DTNHost myHost, DTNHost peer, 
                          CommunityDetection peerCD)
{
    boolean addPeerToMyLocal=false, addMeToPeerLocal=false;
    //初始化两个判断
    SimpleCommunityDetection scd = (SimpleCommunityDetection)peerCD;

    this.localCommunity.add(myHost);
    scd.localCommunity.add(peer);
    //在当前的community中加入当前的host ，而对于peerCD加入相应的peer 

    // 如果需要的话，将peer加入到this的localCommunity中
    if(!this.localCommunity.contains(peer))
    {
        // 计算交集的个数 (scd 的 familiarSet 和 this.localCommunity)
        int count=0, peerFsize = scd.familiarSet.size();
        for(DTNHost h : scd.familiarSet)
            if(this.localCommunity.contains(h))
                count++;

        // 当有很多相同的时候，则将peer加入到当前community中
        if(addPeerToMyLocal = ((double)count)/peerFsize > this.lambda)
        {
            this.localCommunity.add(peer);
        }
    }

	//同样，也判断是否需要将myHost 加入到scd的localCommunity中
    if(!scd.localCommunity.contains(myHost))
    {
        int count = 0, myFsize = this.familiarSet.size();
        for(DTNHost h : this.familiarSet)
            if(scd.localCommunity.contains(h))
                count++;

        if(addMeToPeerLocal = ((double)count)/myFsize > scd.lambda)
        {
            scd.localCommunity.add(myHost);
        }
    }

//判断local communities是否需要进行合并
    if(addPeerToMyLocal || addMeToPeerLocal)
    {
        // Compute set union
        Set<DTNHost> commUnion = new HashSet<DTNHost>(this.localCommunity.size() +
                                                      scd.localCommunity.size() + 2);
        commUnion.addAll(this.localCommunity);
        commUnion.addAll(scd.localCommunity);

		//计算两个localcommunity交集的个数(count)
        int count = 0;
        for(DTNHost h : this.localCommunity)
            if(scd.localCommunity.contains(h))
                count++;

        // 如果交集的个数超过某个阈值，则进行合并
        if(addPeerToMyLocal && count > this.gamma * commUnion.size())
        {
            this.localCommunity.addAll(scd.localCommunity);
        }
        if(addMeToPeerLocal && count > scd.gamma * commUnion.size())
        {
            scd.localCommunity.addAll(this.localCommunity);
        }
    }
}

public void connectionLost(DTNHost myHost, DTNHost peer, 
                           CommunityDetection peerCD, List<Duration> history)
{
    if(this.familiarSet.contains(peer)) return;
    
    // Compute total contact duration
    Iterator<Duration> i = history.iterator();
    double time = 0;
    while(i.hasNext())
    {
        Duration d = i.next();
        time += d.end - d.start;
    }

    // Add peer to familiar set if needed (and by extension to the local comm.)
    if(time > this.familiarThreshold)
    {
        this.familiarSet.add(peer);
        this.localCommunity.add(peer);
    }
}

// initialize
int epochCount = SimClock.getIntTime() / CENTRALITY_TIME_WINDOW;
int[] centralities = new int[epochCount];
int epoch, timeNow = SimClock.getIntTime();
Map<Integer, Set<DTNHost>> nodesCountedInEpoch = 
    new HashMap<Integer, Set<DTNHost>>();

for(int i = 0; i < epochCount; i++)
    nodesCountedInEpoch.put(i, new HashSet<DTNHost>());

for(Map.Entry<DTNHost, List<Duration>> entry : connHistory.entrySet())
{
    DTNHost h = entry.getKey();
    for(Duration d : entry.getValue())
    {
        int timePassed = (int)(timeNow - d.end);

        // if we reached the end of the last epoch, we're done with this node
        if(timePassed > CENTRALITY_TIME_WINDOW * epochCount)
            break;

        // compute the epoch this contact belongs to
        epoch = timePassed / CENTRALITY_TIME_WINDOW;

        // Only consider each node once per epoch
        Set<DTNHost> nodesAlreadyCounted = nodesCountedInEpoch.get(epoch);
        if(nodesAlreadyCounted.contains(h))
            continue;

        // increment the degree for the given epoch
        centralities[epoch]++;
        nodesAlreadyCounted.add(h);
    }
}

int sum = 0;
for(int i = 0; i < epochCount; i++) 
    sum += centralities[i];
this.globalCentrality = ((double)sum) / epochCount;

this.lastGlobalComputationTime = SimClock.getIntTime();

return this.globalCentrality;

/** coordinates of the path  所有的点的list*/
private List<Coord> coords;
/** speeds in the path legs  不同是速度的list*/
private List<Double> speeds;
private int nextWpIndex;

/** Value for infinite distance  */
private static final Double INFINITY = Double.MAX_VALUE;
/** Initial size of the priority queue */
private static final int PQ_INIT_SIZE = 11;

/** Map of node distances from the source node */
private DistanceMap distances;
/** Set of already visited nodes (where the shortest path is known) */
private Set<MapNode> visited;
/** Priority queue of unvisited nodes discovered so far */
private Queue<MapNode> unvisited;
/** Map of previous nodes on the shortest path(s) */
private Map<MapNode, MapNode> prevNodes;

private int [] okMapNodes;//可以访问的map node

private List<MapNode> stops;
private int type; // type of the route
private int index; // index of the previous returned map node
private boolean comingBack;

/** the Dijkstra shortest path finder */
private DijkstraPathFinder pathFinder;

/** Prototype's reference to all routes read for the group */
private List<MapRoute> allRoutes = null;
/** next route's index to give by prototype */
private Integer nextRouteIndex = null;
/** Index of the first stop for a group of nodes (or -1 for random) */
private int firstStopIndex = -1;

/** Route of the movement model's instance */
private MapRoute route;

public static final String BUS_CONTROL_SYSTEM_NR = "busControlSystemNr";
//相应的hashmap ，映射int -> system 
private static HashMap<Integer, BusControlSystem> systems;
//同样，也会映射到BusMovement 和 BusTravellerMovement
private HashMap<Integer, BusMovement> busses;
private HashMap<Integer, BusTravellerMovement> travellers;
private List<Coord> busStops;//公交站台的位置

private SimMap simMap;

static {		DTNSim.registerForReset(BusControlSystem.class.getCanonicalName());
	reset();
}

private int state;
private Path nextPath;// path 
private Coord location;
private Coord latestBusStop;
private BusControlSystem controlSystem;//控制system
private int id;
private ContinueBusTripDecider cbtd;//是否要继续trip
private double[] probabilities;
private double probTakeOtherBus;
private DijkstraPathFinder pathFinder;//寻找最近路径

private Coord startBusStop;
private Coord endBusStop;

private boolean takeBus;

private static int nextID = 0;

private EveningActivityMovement[] eveningActivityNodes;
private int eveningActivityNodesInBuffer;
private Path path;// 路径
private Coord location;//起点
private Coord destination;//目的地
private double waitTimeAtEnd;//等待时间

private HashMap<Integer, EveningActivityMovement> eveningActivityNodes;
private List<Coord> meetingSpots;//见面地点
private EveningTrip[] nextTrips;//下一个目的地

private Random rng;

private static HashMap<Integer, EveningActivityControlSystem> controlSystems;

private static int nrOfMeetingSpots = 10;
//meeting spots 的个数
private int mode;
private boolean ready;
private DijkstraPathFinder pathFinder;//path

private Coord lastWaypoint;
private Coord startAtLocation;

private EveningActivityControlSystem scs;//控制系统
private EveningTrip trip;//to and from 

private boolean readyToShop;

private int id;

private static int nextID = 0;

private int minGroupSize;
private int maxGroupSize;

/** mapping of external id to movement model */
private static Map<String, ExternalMovement> idMapping;
/** initial locations for nodes */
private static List<Tuple<String, Coord>> initLocations;
/** time of the very first location data */
private static double initTime;
/** sampling interval (seconds) of the location data */
private static double samplingInterval;// 采样间隔
/** last read time stamp after preloading */
private static double lastPreloadTime;
/** how many time intervals to load on every preload run */
private static double nrofPreload = 10;
/** minimum number intervals that should be preloaded ahead of sim time */
private static final double MIN_AHEAD_INTERVALS = 2;

/** the very first location of the node */
private Coord intialLocation;
/** queue of path-start-time, path tuples */
private Queue<Tuple<Double, Path>> pathQueue;

/** when was the path currently under construction started */
private double latestPathStartTime;
/** the last location of path waypoint */
private Coord latestLocation;
/** the path currently under construction */
private Path latestPath;

/** is this node active */
private boolean isActive;

/**
 * Represents a point on the path.
 */
public class Entry {
	public double time;
	public double x;
	public double y;
}

/**
 * Describes a node's activity time
 */
public class ActiveTime {
	public double start;
	public double end;
}

// Node's paths
private List<List<ExternalPathMovementReader.Entry>> paths;//记录了相应的所有的path(time , x , y)
private int curPath=0;
private List<ExternalPathMovementReader.ActiveTime> active;//(start,end)

@Override
public Path getPath() {
	// Make sure to not give out paths when the node is not active
	if (!this.isActive()) {
		return null;
	}

	// Check whether we're moving or waiting for the next path to start
	double t = SimClock.getTime();
	if (t < this.paths.get(this.curPath).get(0).time) {
		return null;
	}

	// Get the path
	List<ExternalPathMovementReader.Entry> path =
		this.paths.get(this.curPath);
	this.curPath++;

	// Drop the node to the the beginning of the new path in case the
	// previous path ended somewhere else.
	Coord curPos = super.getHost().getLocation();
	ExternalPathMovementReader.Entry pathStart = path.get(0);
	if (curPos.getX() != pathStart.x ||
			curPos.getY() != pathStart.y) {
		Coord c = new Coord(pathStart.x, pathStart.y);
		super.getHost().setLocation(c);
	}

	// If this is a stationary path, return only the fist point
	if (path.size() == 1) {
		Path p = new Path(0);
		ExternalPathMovementReader.Entry e = path.get(0);
		Coord c = new Coord(e.x, e.y);
		p.addWaypoint(c);
		return p;
	}

	// Build and return the whole path at once
	Path p = new Path();
	for (int i=1; i < path.size(); i++) {
		ExternalPathMovementReader.Entry e = path.get(i);
		ExternalPathMovementReader.Entry e2 = path.get(i-1);
		Coord c = new Coord(e.x, e.y);
		double dt = e.time - e2.time;
		double ds = Math.sqrt( (e.x - e2.x) * (e.x - e2.x) +
				(e.y - e2.y) * (e.y - e2.y));
		double v = ds/dt;
		p.addWaypoint(c, v);
	}

	return p;
}

private double startCoords[];
private int rows;
private int cols;
private double spacing;
private double offset;
private int nodeCount;
private Coord loc;//坐标点

private int mode;
private DijkstraPathFinder pathFinder;

private int distance;

private Coord lastWaypoint;
private Coord homeLocation;//固定的位置

private List<Coord> allHomes;//所有的家庭住址的点

private int timeDiffSTD;
private int timeDifference;

public Path getPath() {
	if (mode == WALKING_HOME_MODE) {
		// Try to find home
		SimMap map = super.getMap();
		if (map == null) {
			return null;
		}
		MapNode thisNode = map.getNodeByCoord(lastWaypoint);
		MapNode destinationNode = map.getNodeByCoord(homeLocation);
		List<MapNode> nodes = pathFinder.getShortestPath(thisNode,
				destinationNode);
		Path path = new Path(generateSpeed());
		for (MapNode node : nodes) {
			path.addWaypoint(node.getLocation());
		}
		lastWaypoint = homeLocation.clone();
		mode = AT_HOME_MODE;

		double newX = lastWaypoint.getX() + (rng.nextDouble() - 0.5) *
			distance;
		if (newX > getMaxX()) {
			newX = getMaxX();
		} else if (newX < 0) {
			newX = 0;
		}
		double newY = lastWaypoint.getY() + (rng.nextDouble() - 0.5) *
			distance;
		if (newY > getMaxY()) {
			newY = getMaxY();
		} else if (newY < 0) {
			newY = 0;
		}
		Coord c = new Coord(newX, newY);
		path.addWaypoint(c);
		return path;
	} else {
		Path path =  new Path(1);
		path.addWaypoint(lastWaypoint.clone());
		mode = READY_MODE;
		return path;
	}

}

/* values for the prototype */
private Coord startLoc; /** The start location of the line */
private Coord endLoc; /** The start location of the line */
private int nodeCount; /** how many nodes in this formation */
private int lastIndex; /** index of the previous node */
/* values for the per-node models */
private Coord loc;

/* values for the prototype */
private Coord startLoc; /** The start location of the line */
private Coord endLoc; /** The start location of the line */
private int initLocType;
private int targetType;
private int nodeCount; /** how many nodes in this formation */
private int lastIndex; /** index of the previous node */

/* values for the per-node models */
private Path nextPath;
private Coord initLoc;

private static int nrOfOffices = 50;//office的数目

private int mode;//相应的模式
private int workDayLength;//工作时长
private int startedWorkingTime;//开始时间
private boolean ready;;
private DijkstraPathFinder pathFinder;//找到最短路径来到达

private ParetoRNG paretoRNG;

private int distance;
private double officeWaitTimeParetoCoeff;
private double officeMinWaitTime;
private double officeMaxWaitTime;

private List<Coord> allOffices;

private Coord lastWaypoint;
private Coord officeLocation;
private Coord deskLocation;

private boolean sittingAtDesk;

private BusTravellerMovement busTravellerMM;
private OfficeActivityMovement workerMM;
private HomeActivityMovement homeMM;
private EveningActivityMovement eveningActivityMovement;
private CarMovement carMM;

private TransportMovement movementUsedForTransfers;

//message buffer size 
public static final String B_SIZE_S = "bufferSize";
//TTL 即最多能够传递的次数 (time to live)
public static final String MSG_TTL_S = "msgTtl";
//如果路由协议没有定义任何特殊的传输message 的序列，那么这将影响传输的顺序；也就是信息传输队列的类型。
public static final String SEND_QUEUE_MODE_S = "sendQueue";
/** Setting value for random queue mode */
public static final int Q_MODE_RANDOM = 1;
/** Setting value for FIFO queue mode */
public static final int Q_MODE_FIFO = 2;
/** Setting string for random queue mode */
public static final String STR_Q_MODE_RANDOM = "RANDOM";
/** Setting string for FIFO queue mode */
public static final String STR_Q_MODE_FIFO = "FIFO";

/** Receive return value for OK */
//当开始传输的时候，返回的结果 
public static final int RCV_OK = 0;
/** Receive return value for busy receiver */
public static final int TRY_LATER_BUSY = 1;
/** Receive return value for an old (already received) message */
public static final int DENIED_OLD = -1;
/** Receive return value for not enough space in the buffer for the msg */
public static final int DENIED_NO_SPACE = -2;
/** Receive return value for messages whose TTL has expired */
public static final int DENIED_TTL = -3;
/** Receive return value for a node low on some resource(s) */
public static final int DENIED_LOW_RESOURCES = -4;
/** Receive return value for a node low on some resource(s) */
public static final int DENIED_POLICY = -5;
/** Receive return value for unspecified reason */
public static final int DENIED_UNSPECIFIED = -99;
/** Maximum Ttl value */
public static final int MAX_TTL_VALUE = 35791394;

private List<MessageListener> mListeners;
/** The messages being transferred with msgID_hostName keys */
private HashMap<String, Message> incomingMessages;
/** The messages this router is carrying */
private HashMap<String, Message> messages;
/** The messages this router has received as the final recipient */
private HashMap<String, Message> deliveredMessages;
/** The messages that Applications on this router have blacklisted */
private HashMap<String, Object> blacklistedMessages;
/** Host where this router belongs to */
private DTNHost host;
/** size of the buffer */
private long bufferSize;
/** TTL for all messages */
protected int msgTtl;
/** Queue mode for sending messages */
private int sendQueueMode;

/** applications attached to the host */
private HashMap<String, Collection<Application>> applications = null;

@SuppressWarnings(value = "unchecked") /* ugly way to make this generic */
protected List sortByQueueMode(List list) {
	switch (sendQueueMode) {
	case Q_MODE_RANDOM:
		Collections.shuffle(list, new Random(SimClock.getIntTime()));
		break;
	case Q_MODE_FIFO:
		Collections.sort(list,
				new Comparator() {
			/** Compares two tuples by their messages' receiving time */
			public int compare(Object o1, Object o2) {
				double diff;
				Message m1, m2;

				if (o1 instanceof Tuple) {
					m1 = ((Tuple<Message, Connection>)o1).getKey();
					m2 = ((Tuple<Message, Connection>)o2).getKey();
				}
				else if (o1 instanceof Message) {
					m1 = (Message)o1;
					m2 = (Message)o2;
				}
				else {
					throw new SimError("Invalid type of objects in " +
							"the list");
				}

				diff = m1.getReceiveTime() - m2.getReceiveTime();
				if (diff == 0) {
					return 0;
				}
				return (diff < 0 ? -1 : 1);
			}
		});
		break;
	/* add more queue modes here */
	default:
		throw new SimError("Unknown queue mode " + sendQueueMode);
	}

@Override
public void update() {
	super.update();

	/* in theory we can have multiple sending connections even though
	  currently all routers allow only one concurrent sending connection */
	for (int i=0; i<this.sendingConnections.size(); ) {
		boolean removeCurrent = false;
		Connection con = sendingConnections.get(i);

		/* finalize ready transfers */
		if (con.isMessageTransferred()) {
			if (con.getMessage() != null) {
				transferDone(con);
				con.finalizeTransfer();
			} /* else: some other entity aborted transfer */
			removeCurrent = true;
		}
		/* remove connections that have gone down */
		else if (!con.isUp()) {
			if (con.getMessage() != null) {
				transferAborted(con);
				con.abortTransfer();
			}
			removeCurrent = true;
		}

		if (removeCurrent) {
			// if the message being sent was holding excess buffer, free it
			if (this.getFreeBufferSize() < 0) {
				this.makeRoomForMessage(0);
			}
			sendingConnections.remove(i);
		}
		else {
			/* index increase needed only if nothing was removed */
			i++;
		}
	}

	/* time to do a TTL check and drop old messages? Only if not sending */
	if (SimClock.getTime() - lastTtlCheck >= TTL_CHECK_INTERVAL &&
			sendingConnections.size() == 0) {
		dropExpiredMessages();
		lastTtlCheck = SimClock.getTime();
	}

	if (energy != null) {
		/* TODO: add support for other interfaces */
		NetworkInterface iface = getHost().getInterface(1);
		energy.update(iface, getHost().getComBus());
	}
}

public EpidemicOracleRouter(Settings s) {
	super(s);
}

/**
 * Copy constructor.
 * @param r The router prototype where setting values are copied from
 */
protected EpidemicOracleRouter(EpidemicOracleRouter r) {
	super(r);
	allRouters.add(this);
}

public Message messageTransferred(String id, DTNHost from) {
	Message m = super.messageTransferred(id, from);

	if (m.getTo() == this.getHost()) {
		for (EpidemicOracleRouter r : allRouters) {
			if (r != this && r != from.getRouter()) {
				r.removeDeliveredMessage(id);
			}
		}
	} else {
		sendMessageToConnected(m);
	}

	return m;
}

public void update() {
	super.update();
	if (isTransferring() || !canStartTransfer()) {
		return; // transferring, don't try other connections yet
	}

	// Try first the messages that can be delivered to final recipient
	if (exchangeDeliverableMessages() != null) {
		return; // started a transfer, don't try others (yet)
	}

	// then try any/all message to any/all connection
	this.tryAllMessagesToAllConnections();
}

protected int checkReceiving(Message m, DTNHost from) {
	int recvCheck = super.checkReceiving(m, from);

	if (recvCheck == RCV_OK) {
		/* don't accept a message that has already traversed this node */
		if (m.getHops().contains(getHost())) {
			recvCheck = DENIED_OLD;
		}
	}

	return recvCheck;
}

public static final String NM_COUNT_S = "nmcount";
private int countRange[];

private int getPeerMessageCount(Message m) {
	DTNHost me = getHost();
	String id = m.getId();
	int peerMsgCount = 0;

	for (Connection c : getConnections()) {
		if (c.getOtherNode(me).getRouter().hasMessage(id)) {
			peerMsgCount++;
		}
	}
	return peerMsgCount;
}

public void update() {
	int peerMsgCount;
	Vector<String> messagesToDelete = new Vector<String>();
	super.update();

	if (isTransferring() || !canStartTransfer()) {
		return; /* transferring, don't try other connections yet */
	}

	/* Try first the messages that can be delivered to final recipient */
	if (exchangeDeliverableMessages() != null) {
		return;
	}
	this.tryAllMessagesToAllConnections();

	/* see if need to drop some messages... */
	for (Message m : getMessageCollection()) {
		peerMsgCount = getPeerMessageCount(m);
		if (peerMsgCount < this.countRange[0] ||
				peerMsgCount > this.countRange[1]) {
			messagesToDelete.add(m.getId());
		}
	}
	for (String id : messagesToDelete) { /* ...and drop them */
		this.deleteMessage(id, true);
	}
}

   // setting 文件中的名字空间 (name)
public static final String MAXPROP_NS = "MaxPropRouter";
// 传递可能性的最大值的设定
public static final String PROB_SET_MAX_SIZE_S = "probSetMaxSize";
// 一个default 的值
   public static final int DEFAULT_PROB_SET_MAX_SIZE = 50;
   private static int probSetMaxSize;
//MeetingProbabilitySet 声明的位置为 routing.maxprop 中，
//其主要是为了来保存和进行关于meeting probability 的操作
//最主要的，包括了一个Map<Integer,Double> 也就是相应下一个结点的连接可能性。
private MeetingProbabilitySet probs;
//进行相应的映射
private Map<Integer, MeetingProbabilitySet> allProbs;
/** the cost-to-node calculator Dijkstra 算法*/
private MaxPropDijkstra dijkstra;
/** IDs of the messages that are known to have reached the final dst */
private Set<String> ackedMessageIds;
/** message(key) -> cost(value) */
private Map<Integer, Double> costsForMessages;
/** From host of the last cost calculation */
private DTNHost lastCostFrom;

/**记录了向哪些host 发送了具体的哪些message */
private Map<DTNHost, Set<String>> sentMessages;

// 在每次传输机会，能够传输的平均bytes	（采样）
public static int BYTES_TRANSFERRED_AVG_SAMPLES = 10;
private int[] avgSamples;
private int nextSampleIndex = 0;

// 当前的一个value 值
private int avgTransferredBytes = 0;

/** The alpha parameter string*/
public static final String ALPHA_S = "alpha";

/** The alpha variable, default = 1;*/
private double alpha;

/** The default value for alpha */
public static final double DEFAULT_ALPHA = 1.0;

public void updateMeetingProbFor(Integer index) {
       Map.Entry<Integer, Double> smallestEntry = null;
       double smallestValue = Double.MAX_VALUE;

	this.lastUpdateTime = SimClock.getTime();

	if (probs.size() == 0) { // first entry
		probs.put(index, 1.0);
		return;
	}

	double newValue = getProbFor(index) + alpha;
	probs.put(index, newValue);
	/* now the sum of all entries is 1+alpha;
	 * normalize to one by dividing all the entries by 1+alpha */
	for (Map.Entry<Integer, Double> entry : probs.entrySet()) {
		entry.setValue(entry.getValue() / (1+alpha));
           if (entry.getValue() < smallestValue) {
               smallestEntry = entry;
               smallestValue = entry.getValue();
           }
	}
       if (probs.size() >= maxSetSize) {
           if (DEBUG) core.Debug.p("Probsize: " + probs.size() + " dropping " +
				probs.remove(smallestEntry.getKey()));
       }
}

private void relax(Integer node) {
	double nodeDist = distancesFromStart.get(node);
	Collection<Integer> neighbors;

	if (!this.probs.containsKey(node)) {
		return; // node's neighbors are not known
	}

	neighbors =	this.probs.get(node).getAllProbs().keySet();

	for (Integer n : neighbors) {
		if (visited.contains(n)) {
			continue; // skip visited nodes
		}

		// n node's distance from path's source node
		double nDist = nodeDist + getDistance(node, n);

		if (distancesFromStart.get(n) > nDist) {
			// stored distance > found dist -> update
			prevNodes.put(n, node); // for debugging
			setDistance(n, nDist);
		}
	}
}

protected void updateParam()
{
	double err = .01;
	double ntarg = Math.ceil(timescale/meanIET);
	double ee = 1;
	double alphadiff = .1;
	int ob = 0;
	double fstable;
	double fnzero;
	double fnone;
	double eezero;
	double eeone;
	double A;

	/*
	 * the estimation algorith does not work for timescales
	 * shorter than the mean IET - so use defaults
	 */
	if (meanIET > (double)timescale) {
		System.out.printf("meanIET %f > %d timescale\n",meanIET,timescale);
		return;
	}

	if (meanIET == 0) {
		System.out.printf("Mean IET == 0\n");
		return;
	}

	if (meanENC == 0) {
		System.out.printf("Mean ENC == 0\n");
		return;
	}

	while (ee != err) {
		A = Math.pow(1+alpha,meanENC+1);
		fstable = alpha/(A-1);
		fnzero = (alpha/A)*(1-Math.pow(A,-ntarg))/(1-1/A);
		fnone  = fnzero + 1/(Math.pow(A,ntarg));
		eezero = Math.abs(fnzero-fstable);
		eeone  = Math.abs(fnone -fstable);
		ee = Math.max(eezero,eeone);

		if (ee > err ) {
			if (ob == 2) {
				alphadiff = alphadiff / 2.0;
			}
			ob = 1;
			alpha = alpha+alphadiff;
		} else {
			if (ee < (err-err*0.001)) {
				if (ob == 1) {
					alphadiff = alphadiff / 2.0;
				}
				ob = 2;
				alpha = alpha - alphadiff;

				// double precision floating makes problems...
				if ((alpha <= 0) | (((1 + alpha) - 1) == 0)) {
					alpha = alphadiff;
					alphadiff = alphadiff / 2.0;
					ob = 0;
				}
			} else {
				ee = err;
			}
		}
	}
	probs.setAlpha(alpha);
}

public static final double P_INIT = 0.75;
public static final double DEFAULT_BETA = 0.25;
public static final double DEFAULT_GAMMA = 0.98;

public static final String PROPHET_NS = "ProphetRouter";
// 在time unit 中seconds 的数目，需要根据scenario进行相应的调整。
public static final String SECONDS_IN_UNIT_S ="secondsInTimeUnit";
//固定的传输比例
public static final String BETA_S = "beta";

// 相应的衰减
public static final String GAMMA_S = "gamma";

/** the value of nrof seconds in time unit -setting */
private int secondsInTimeUnit;
/** value of beta setting */
private double beta;
/** value of gamma setting */
private double gamma;

/** delivery predictabilities */
private Map<DTNHost, Double> preds;
/** last delivery predictability update (sim)time */
private double lastAgeUpdate;

private void updateDeliveryPredFor(DTNHost host) {
	double oldValue = getPredFor(host);
	double newValue = oldValue + (1 - oldValue) * P_INIT;
	preds.put(host, newValue);
}

private void updateTransitivePreds(DTNHost host) {
	MessageRouter otherRouter = host.getRouter();
	assert otherRouter instanceof ProphetRouter : "PRoPHET only works " +
		" with other routers of same type";

	double pForHost = getPredFor(host); // P(a,b)
	Map<DTNHost, Double> othersPreds =
		((ProphetRouter)otherRouter).getDeliveryPreds();

	for (Map.Entry<DTNHost, Double> e : othersPreds.entrySet()) {
		if (e.getKey() == getHost()) {
			continue; // don't add yourself
		}

		double pOld = getPredFor(e.getKey()); // P(a,c)_old
		double pNew = pOld + ( 1 - pOld) * pForHost * e.getValue() * beta;
		preds.put(e.getKey(), pNew);
	}
}

private GridCell[] getNeighborCells(int row, int col) {
	return new GridCell[] {
		cells[row-1][col-1],cells[row-1][col],cells[row-1][col+1],//1st row
		cells[row][col-1],cells[row][col],cells[row][col+1],//2nd row
		cells[row+1][col-1],cells[row+1][col],cells[row+1][col+1]//3rd row
	};
}

public void connect(NetworkInterface anotherInterface) {// 进行连接
	if (isScanning()
			&& anotherInterface.getHost().isRadioActive()
			&& isWithinRange(anotherInterface)
			&& !isConnected(anotherInterface)
			&& (this != anotherInterface)) {

		Connection con = new VBRConnection(this.host, this,
				anotherInterface.getHost(), anotherInterface);
		connect(con,anotherInterface);
	}
}

public int getTransmitSpeed(NetworkInterface ni) {
	double distance;
	double fractionIndex;
	double decimal;
	double speed;
	int index;

	/* distance to the other interface */
	distance = ni.getLocation().distance(this.getLocation());

	if (distance >= this.transmitRange) {
		return 0;
	}

	/* interpolate between the two speeds */
	fractionIndex = (distance / this.transmitRange) *
			(this.transmitSpeeds.length - 1);
	index = (int)(fractionIndex);
	decimal = fractionIndex - index;

	speed = this.transmitSpeeds[index] * (1-decimal) +
			this.transmitSpeeds[index + 1] * decimal;

	return (int)speed;
}

numberOfTransmissions = 0;
int numberOfActive = 1;
for (Connection con : this.connections) {
	if (con.getMessage() != null) {
		numberOfTransmissions++;
	}
	if (((InterferenceLimitedInterface)con.getOtherInterface(this)).
			isTransferring() == true) {
		numberOfActive++;
	}
}

int ntrans = numberOfTransmissions;
if ( numberOfTransmissions < 1) ntrans = 1;
if ( numberOfActive <2 ) numberOfActive = 2;

// Based on the equation of Gupta and Kumar - and the transmission speed
// is divided equally to all the ongoing transmissions
currentTransmitSpeed = (int)Math.floor((double)transmitSpeed /
		(Math.sqrt((1.0*numberOfActive) *
				Math.log(1.0*numberOfActive))) /
					ntrans );

public static void main(String[] args) {
	boolean batchMode = false;
	int nrofRuns[] = {0,1};
	String confFiles[];
	int firstConfIndex = 0;
	int guiIndex = 0;

	/* set US locale to parse decimals in consistent way */
	java.util.Locale.setDefault(java.util.Locale.US);

	if (args.length > 0) {
		if (args[0].equals(BATCH_MODE_FLAG)) {
			batchMode = true;
               if (args.length == 1) {
                   firstConfIndex = 1;
               }
               else {
                   nrofRuns = parseNrofRuns(args[1]);
                   firstConfIndex = 2;
               }
		}
		else { /* GUI mode */
			try { /* is there a run index for the GUI mode ? */
				guiIndex = Integer.parseInt(args[0]);
				firstConfIndex = 1;
			} catch (NumberFormatException e) {
				firstConfIndex = 0;
			}
		}
		confFiles = args;
	}
	else {
		confFiles = new String[] {null};
	}

	initSettings(confFiles, firstConfIndex);

	if (batchMode) {
		long startTime = System.currentTimeMillis();
		for (int i=nrofRuns[0]; i<nrofRuns[1]; i++) {
			print("Run " + (i+1) + "/" + nrofRuns[1]);
			Settings.setRunIndex(i);
			resetForNextRun();
			new DTNSimTextUI().start();
		}
		double duration = (System.currentTimeMillis() - startTime)/1000.0;
		print("---\nAll done in " + String.format("%.2f", duration) + "s");
	}
	else {
		Settings.setRunIndex(guiIndex);
		new DTNSimGUI().start();
	}
}

private void load0(LineReader lr) throws IOException {
    StringBuilder outBuffer = new StringBuilder();
    int limit;
    int keyLen;
    int valueStart;
    boolean hasSep;
    boolean precedingBackslash;

    while ((limit = lr.readLine()) >= 0) {
        keyLen = 0;
        valueStart = limit;
        hasSep = false;

        //System.out.println("line=<" + new String(lineBuf, 0, limit) + ">");
        precedingBackslash = false;
        while (keyLen < limit) {
            char c = lr.lineBuf[keyLen];
            //need check if escaped.
            if ((c == '=' ||  c == ':') && !precedingBackslash) {
                valueStart = keyLen + 1;
                hasSep = true;
                break;
            } else if ((c == ' ' || c == '\t' ||  c == '\f') && !precedingBackslash) {
                valueStart = keyLen + 1;
                break;
            }
            if (c == '\\') {
                precedingBackslash = !precedingBackslash;
            } else {
                precedingBackslash = false;
            }
            keyLen++;
        }
        while (valueStart < limit) {
            char c = lr.lineBuf[valueStart];
            if (c != ' ' && c != '\t' &&  c != '\f') {
                if (!hasSep && (c == '=' ||  c == ':')) {
                    hasSep = true;
                } else {
                    break;
                }
            }
            valueStart++;
        }
        String key = loadConvert(lr.lineBuf, 0, keyLen, outBuffer);
        String value = loadConvert(lr.lineBuf, valueStart, limit - valueStart, outBuffer);
        put(key, value);
    }
}

private Stack<String> oldNamespaces;
private Stack<String> secondaryNamespaces;

	public Object createIntializedObject(String className) {
		Class<?>[] argsClass = {Settings.class};
		Object[] args = {this};

		return loadObject(className, argsClass, args);
	}

Class<?> objClass = getClass(className);//通过getClass来创建相应的类对象，获得相应的反射

Settings s = new Settings(SCENARIO_NS);//"Scenario"
createHosts();

this.world = new World(hosts, worldSizeX, worldSizeY, updateInterval,updateListeners, simulateConnections,
eqHandler.getEventQueues());

private static int nextAddress = 0;
private int address;

private Coord location; 	// where is the host
private Coord destination;	// where is it going

private MessageRouter router; //路由
private MovementModel movement; // 移动
private Path path;//路径
private double speed;
private double nextTimeToMove;
private String name;
private List<MessageListener> msgListeners;
private List<MovementListener> movListeners;
private List<NetworkInterface> net;//网络接口
private ModuleCommunicationBus comBus;

public World(List<DTNHost> hosts, int sizeX, int sizeY,
		double updateInterval, List<UpdateListener> updateListeners,
		boolean simulateConnections, List<EventQueue> eventQueues) {
	this.hosts = hosts;
	this.sizeX = sizeX;
	this.sizeY = sizeY;
	this.updateInterval = updateInterval;
	this.updateListeners = updateListeners;
	this.simulateConnections = simulateConnections;
	this.eventQueues = eventQueues;

	this.simClock = SimClock.getInstance();
	this.scheduledUpdates = new ScheduledUpdatesQueue();
	this.isCancelled = false;

	setNextEventQueue();
	initSettings();
}

while (simTime < endTime && !simCancelled){
	if (guiControls.isPaused()) {
		wait(10); // release CPU resources when paused
	}
	else {
		try {
			world.update();
		} catch (AssertionError e) {
			// handles both assertion errors and SimErrors
			processAssertionError(e);
		}
		simTime = SimClock.getTime();
	}
	this.update(false);
}

private void moveHosts(double timeIncrement) {
	for (int i=0,n = hosts.size(); i<n; i++) {
		DTNHost host = hosts.get(i);
		host.move(timeIncrement);
	}

public void update(boolean simulateConnections) {
	if (!isRadioActive()) {
		// Make sure inactive nodes don't have connections
		tearDownAllConnections();
		return;
	}

	if (simulateConnections) {
		for (NetworkInterface i : net) {
			i.update();
		}
	}
	this.router.update();
}