Removed deprecated `Position`-Interface

src/de/tud/kom/p2psim/api/common/Position.java

-/*
- * Copyright (c) 2005-2010 KOM – Multimedia Communications Lab
- *
- * This file is part of PeerfactSim.KOM.
- * 
- * PeerfactSim.KOM 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 3 of the License, or
- * any later version.
- * 
- * PeerfactSim.KOM 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 PeerfactSim.KOM.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-package de.tud.kom.p2psim.api.common;
-
-import de.tudarmstadt.maki.simonstrator.api.common.Transmitable;
-import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
-
-/**
- * The common interface for positions within PeerfactSim, this hides the
- * business logic of a PositionVector in util.position.
- * 
- * You should consider extending PositionVector for your implementations.
- * 
- * @author Bjoern Richerzhagen
- * @version 1.0, 05/26/2011
- * @deprecated please consider using {@link Location} instead!
- */
-@Deprecated
-public interface Position extends Transmitable, Cloneable, Location {
-
-	/**
-	 * Get the distance of this position compared to any other Position, if they
-	 * have the same number of dimensions and are compatible.
-	 * 
-	 * @param position
-	 * @return
-	 */
-	public double getDistance(Position position);
-
-	/**
-	 * Calculates the angle <b>in rad</b> from the current position to the
-	 * target.
-	 * 
-	 * @param target
-	 * @return An angle in rad between -PI and PI, where 0 is "East", or the
-	 *         direction of the positive x-Axis
-	 */
-	public double getAngle(Position target);
-
-	/**
-	 * This method should be consistent with the getDistance and
-	 * getAngle-methods. It returns a Position that has the given distance and
-	 * angle from the current position.
-	 * 
-	 * @param distance
-	 * @param angle
-	 *            an angle in rad between -PI and PI, where 0 is the direction
-	 *            of the positive x-Axis and angles are incremented
-	 *            counter-clockwise (mathematical)
-	 * @return
-	 */
-	public Position getTarget(double distance, double angle);
-
-	/**
-	 * CLone a Position, ensuring there is no information propagation due to
-	 * Java. Consider a clone() as some kind of snapshot of the current state of
-	 * the cloned position. It is very important to call clone() in scenarios
-	 * with moving hosts!
-	 * 
-	 * @return
-	 */
-	public Position clone();
-
-}

src/de/tud/kom/p2psim/api/network/NetLayer.java

@@ -19,40 +19,40 @@
  */
 
 
-
-package de.tud.kom.p2psim.api.network;
-
-import de.tud.kom.p2psim.api.common.Position;
+
+package de.tud.kom.p2psim.api.network;
+
 import de.tud.kom.p2psim.api.common.SimHost;
 import de.tud.kom.p2psim.api.network.routing.RoutingAlgorithm;
 import de.tudarmstadt.maki.simonstrator.api.Message;
 import de.tudarmstadt.maki.simonstrator.api.component.network.Bandwidth;
 import de.tudarmstadt.maki.simonstrator.api.component.network.NetID;
 import de.tudarmstadt.maki.simonstrator.api.component.network.NetInterface;
-
-/**
- * The NetLayer provides a general interface to encapsulate various networking
- * models. This way, it is possible to use network solutions with different
- * abstraction levels and complexity. For instance, one can choose either
- * between a lightweight simple implementation which offers an adequate model
- * with minimum demands in resource requirements and a more complex
- * implementation capable to model fairshare bandwidth allocation of TCP but
- * having a lot of CPU consumption.
- * 
- * @author Sebastian Kaune
- * @author Konstantin Pussep
- * @version 3.0, 11/29/2007
- * 
- */
-
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
+
+/**
+ * The NetLayer provides a general interface to encapsulate various networking
+ * models. This way, it is possible to use network solutions with different
+ * abstraction levels and complexity. For instance, one can choose either
+ * between a lightweight simple implementation which offers an adequate model
+ * with minimum demands in resource requirements and a more complex
+ * implementation capable to model fairshare bandwidth allocation of TCP but
+ * having a lot of CPU consumption.
+ * 
+ * @author Sebastian Kaune
+ * @author Konstantin Pussep
+ * @version 3.0, 11/29/2007
+ * 
+ */
+
 public interface NetLayer extends NetInterface {
 
 	/**
 	 * 
 	 * @return
 	 */
-	public SimHost getHost();
-
+	public SimHost getHost();
+
 	/**
 	 * 
 	 * Deliver a message with the given data to the destination using the given
@@ -68,48 +68,48 @@ public interface NetLayer extends NetInterface {
 	 *            the remote receiver
 	 * @param protocol
 	 *            the used network protocol
-	 */
-	public void send(Message msg, NetID receiver, NetProtocol protocol);
-
-	/**
-	 * Returns whether the network layer has connectivity to the physical
-	 * network.
-	 * 
-	 * @return return true if the network layer has connectivity to the physical
-	 *         network
-	 */
-	public boolean isOnline();
-
-	/**
-	 * Returns whether the network layer has connectivity to the physical
-	 * network.
-	 * 
-	 * @return return true if the network layer does not have connectivity to
-	 *         the physical network
-	 */
-	public boolean isOffline();
-
-	/**
-	 * Returns the NetID of a NetLayer instance
-	 * 
-	 * @return the NetID of a given NetLayer instance
-	 */
-	public NetID getNetID();
-
-	/**
-	 * Establishes the connection to the physical network. Further to this, if
-	 * installed, the correspondent ConnectivityListener will be informed about
-	 * the changes in connectivity.
-	 * 
-	 */
-	public void goOnline();
-
-	/**
-	 * Releases the connection to the physical network. Further to this, if
-	 * installed, the correspondent ConnectivityListener will be informed about
-	 * the changes in connectivity.
-	 * 
-	 */
+	 */
+	public void send(Message msg, NetID receiver, NetProtocol protocol);
+
+	/**
+	 * Returns whether the network layer has connectivity to the physical
+	 * network.
+	 * 
+	 * @return return true if the network layer has connectivity to the physical
+	 *         network
+	 */
+	public boolean isOnline();
+
+	/**
+	 * Returns whether the network layer has connectivity to the physical
+	 * network.
+	 * 
+	 * @return return true if the network layer does not have connectivity to
+	 *         the physical network
+	 */
+	public boolean isOffline();
+
+	/**
+	 * Returns the NetID of a NetLayer instance
+	 * 
+	 * @return the NetID of a given NetLayer instance
+	 */
+	public NetID getNetID();
+
+	/**
+	 * Establishes the connection to the physical network. Further to this, if
+	 * installed, the correspondent ConnectivityListener will be informed about
+	 * the changes in connectivity.
+	 * 
+	 */
+	public void goOnline();
+
+	/**
+	 * Releases the connection to the physical network. Further to this, if
+	 * installed, the correspondent ConnectivityListener will be informed about
+	 * the changes in connectivity.
+	 * 
+	 */
 	public void goOffline();
 
 	/**
@@ -122,8 +122,8 @@ public interface NetLayer extends NetInterface {
 	 * which is described by two numbers--its latitude and its longitude.
 	 * 
 	 * @return Position the appropriate position
-	 */
-	public Position getNetPosition();
+	 */
+	public Location getNetPosition();
 
 	/**
 	 * Returns the maximum physical bandwidth that is available at the given
@@ -131,8 +131,8 @@ public interface NetLayer extends NetInterface {
 	 * and download connections are closed.
 	 * 
 	 * @return
-	 */
-	public Bandwidth getMaxBandwidth();
+	 */
+	public Bandwidth getMaxBandwidth();
 	
 	/**
 	 * Returns the current available download bandwidth of the network layer as
@@ -140,25 +140,25 @@ public interface NetLayer extends NetInterface {
 	 * connections.
 	 * 
 	 * @return the available download bandwidth
-	 */
-	public Bandwidth getCurrentBandwidth();
-	
-	/**
-	 * Adds the given NetMessageListener as a handler for incoming NetMsgEvents
-	 * triggered by the NetLayer which implements the message passing from the
-	 * NetLayer to a layer above.
-	 * 
-	 * @param listener
-	 *            the listener for network events
-	 */
-	public void addNetMsgListener(NetMessageListener listener);
-
-	/**
-	 * Removes the given NetMessageListener which handles incoming NetMsgEvents
-	 * 
-	 * @param listener
-	 *            the listener for network events
-	 */
+	 */
+	public Bandwidth getCurrentBandwidth();
+	
+	/**
+	 * Adds the given NetMessageListener as a handler for incoming NetMsgEvents
+	 * triggered by the NetLayer which implements the message passing from the
+	 * NetLayer to a layer above.
+	 * 
+	 * @param listener
+	 *            the listener for network events
+	 */
+	public void addNetMsgListener(NetMessageListener listener);
+
+	/**
+	 * Removes the given NetMessageListener which handles incoming NetMsgEvents
+	 * 
+	 * @param listener
+	 *            the listener for network events
+	 */
 	public void removeNetMsgListener(NetMessageListener listener);
-
-}
+
+}

src/de/tud/kom/p2psim/api/topology/Topology.java

@@ -26,6 +26,7 @@ import de.tud.kom.p2psim.api.topology.social.SocialView;
 import de.tud.kom.p2psim.api.topology.views.TopologyView;
 import de.tud.kom.p2psim.api.topology.waypoints.WaypointModel;
 import de.tud.kom.p2psim.impl.topology.PositionVector;
+import de.tudarmstadt.maki.simonstrator.api.component.GlobalComponent;
 
 /**
  * We provide a global Topology-Object (ie. this object is only created once in
@@ -36,7 +37,7 @@ import de.tud.kom.p2psim.impl.topology.PositionVector;
  * @author Bjoern Richerzhagen
  * @version 1.0, 21.02.2012
  */
-public interface Topology {
+public interface Topology extends GlobalComponent {
 
 	/**
 	 * This Position Vector contains the upper bounds for each dimension used in

src/de/tud/kom/p2psim/api/topology/TopologyComponent.java

@@ -20,9 +20,7 @@
 
 package de.tud.kom.p2psim.api.topology;
 
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.common.SimHostComponent;
-import de.tud.kom.p2psim.api.energy.EnergyComponent;
 import de.tud.kom.p2psim.api.topology.movement.MovementListener;
 import de.tud.kom.p2psim.api.topology.movement.MovementSupported;
 import de.tud.kom.p2psim.api.topology.views.TopologyView;
@@ -40,33 +38,10 @@ import de.tudarmstadt.maki.simonstrator.api.component.topology.UnderlayTopologyP
 public interface TopologyComponent extends SimHostComponent, MovementSupported,
 		MovementListener, UnderlayTopologyProvider, LocationSensor {
 
-	/**
-	 * Abstract QoS-Classes for the Accuracy of the position. Implementation
-	 * depends on the {@link EnergyComponent}
-	 * 
-	 * @author Bjoern Richerzhagen
-	 * @version 1.0, 26.02.2012
-	 */
-	@Deprecated
-	public static enum PositionAccuracy {
-		HIGH, MEDIUM, LOW
-	}
-
-	/**
-	 * This uses an {@link EnergyComponent} for position retrieving (ie a GPS).
-	 * A call might trigger energy consumption and the result will in most cases
-	 * not be 100% accurate. Use this in your application if you want to add
-	 * another layer of realism.
-	 * 
-	 * @param accuracy
-	 *            a QoS-Class for the accuracy
-	 * @return An estimate of the current position
-	 */
-	@Deprecated
-	public Position getPosition(PositionAccuracy accuracy);
-
 	/**
 	 * Returns the Topology-Object that provides access to {@link TopologyView}s
+	 * Note: the {@link Topology} is also available as a GlobalComponent via the
+	 * Binder-class.
 	 * 
 	 * @return
 	 */

src/de/tud/kom/p2psim/api/topology/obstacles/Obstacle.java

@@ -24,7 +24,6 @@ import java.util.List;
 
 import com.vividsolutions.jts.geom.Geometry;
 
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.topology.views.TopologyView;
 import de.tud.kom.p2psim.impl.topology.PositionVector;
 

src/de/tud/kom/p2psim/api/topology/views/TopologyView.java

@@ -23,13 +23,13 @@ package de.tud.kom.p2psim.api.topology.views;
 import java.util.Collection;
 import java.util.List;
 
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.linklayer.mac.Link;
 import de.tud.kom.p2psim.api.linklayer.mac.MacAddress;
 import de.tud.kom.p2psim.api.linklayer.mac.MacLayer;
 import de.tud.kom.p2psim.api.linklayer.mac.PhyType;
 import de.tud.kom.p2psim.api.topology.TopologyListener;
 import de.tud.kom.p2psim.api.topology.movement.MovementListener;
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
 
 /**
  * Each MAC has a view on the global topology of hosts (ie. the
@@ -119,7 +119,7 @@ public interface TopologyView extends TopologyListener, MovementListener {
 	 *            The {@link MacAddress} of the host
 	 * @return The real Position of the Host.
 	 */
-	public Position getPosition(MacAddress address);
+	public Location getPosition(MacAddress address);
 
 	/**
 	 * Gets the real distance between the two hosts.

src/de/tud/kom/p2psim/api/topology/views/wifi/phy/PropagationLossModel.java

@@ -20,7 +20,7 @@
 
 package de.tud.kom.p2psim.api.topology.views.wifi.phy;
 
-import de.tud.kom.p2psim.api.common.Position;
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
 
 /**
  * This interface is for the calculation of the propagation loss of an
@@ -52,8 +52,8 @@ public abstract class PropagationLossModel {
 	 *            The second position
 	 * @return The RX power in dBm
 	 */
-	public abstract double getRxPowerDbm(double txPowerDbm, Position a,
-			Position b);
+	public abstract double getRxPowerDbm(double txPowerDbm, Location a,
+			Location b);
 
 	/**
 	 * Gets the RX Power in dBm for the distance.

src/de/tud/kom/p2psim/impl/linklayer/mac/wifi/AbstractRateManager.java

@@ -28,13 +28,13 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.linklayer.mac.MacAddress;
 import de.tud.kom.p2psim.api.linklayer.mac.MacLayer;
 import de.tud.kom.p2psim.api.topology.views.wifi.phy.PropagationLossModel;
 import de.tud.kom.p2psim.api.topology.views.wifi.phy.WifiMode;
 import de.tud.kom.p2psim.api.topology.views.wifi.phy.WifiPhy.Standard_802_11;
 import de.tud.kom.p2psim.impl.topology.views.wifi.phy.InterferenceHelper;
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
 
 /**
  * This class is an interface for other implementation of Rate Managers. The
@@ -598,8 +598,8 @@ public abstract class AbstractRateManager {
 	 * antenna. <br>
 	 * This is only a helper to calculate the SNR in the AdHocMac.
 	 */
-	public double calculateActuallySNR(Position startPosition,
-			Position targetPosition, WifiMode mode, double txPowerDbm) {
+	public double calculateActuallySNR(Location startPosition,
+			Location targetPosition, WifiMode mode, double txPowerDbm) {
 		InterferenceHelper helper = mac.getWifiTopologyView()
 				.getInterferenceHelper();
 		double noiseInterferenceW = helper

src/de/tud/kom/p2psim/impl/linklayer/mac/wifi/Ieee80211AdHocMac.java

@@ -28,7 +28,6 @@ import java.util.Random;
 
 import de.tud.kom.p2psim.api.analyzer.LinklayerAnalyzer;
 import de.tud.kom.p2psim.api.analyzer.MessageAnalyzer.Reason;
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.common.SimHost;
 import de.tud.kom.p2psim.api.linklayer.LinkLayerMessage;
 import de.tud.kom.p2psim.api.linklayer.mac.Link;
@@ -47,6 +46,7 @@ import de.tud.kom.p2psim.impl.linklayer.DefaultLinkMessageEvent;
 import de.tud.kom.p2psim.impl.linklayer.mac.AbstractMacLayer;
 import de.tud.kom.p2psim.impl.linklayer.mac.wifi.AbstractRateManager.RateManagerTypes;
 import de.tud.kom.p2psim.impl.linklayer.mac.wifi.DcfManager.WifiState;
+import de.tud.kom.p2psim.impl.topology.PositionVector;
 import de.tud.kom.p2psim.impl.topology.views.wifi.WifiTopologyView;
 import de.tud.kom.p2psim.impl.util.LiveMonitoring;
 import de.tud.kom.p2psim.impl.util.LiveMonitoring.ProgressValue;
@@ -56,6 +56,7 @@ import de.tudarmstadt.maki.simonstrator.api.Monitor.Level;
 import de.tudarmstadt.maki.simonstrator.api.Randoms;
 import de.tudarmstadt.maki.simonstrator.api.Time;
 import de.tudarmstadt.maki.simonstrator.api.component.core.MonitorComponent.AnalyzerNotAvailableException;
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
 import de.tudarmstadt.maki.simonstrator.api.operation.AbstractOperation;
 
 /**
@@ -671,14 +672,12 @@ public class Ieee80211AdHocMac extends AbstractMacLayer {
 	/**
 	 * Gets a copy of the real position of this host.
 	 * 
+	 * Clone <strong>ONLY</strong> here.
+	 * 
 	 * @return The position of this host.
 	 */
-	private Position getPosition() {
-		/*
-		 * FIXME this leads to serious performance degradations. Do we REALLY
-		 * need a copy?
-		 */
-		return this.getHost().getTopologyComponent().getRealPosition(); // .clone();
+	private PositionVector getPosition() {
+		return this.getHost().getTopologyComponent().getRealPosition().clone();
 	}
 
 	/**
@@ -919,9 +918,9 @@ public class Ieee80211AdHocMac extends AbstractMacLayer {
 			WifiMacEventInformation eInfo = (WifiMacEventInformation) eventInfo;
 
 			// startPosition is from receiver (because ack come from this!)
-			Position startPosition = ((Ieee80211AdHocMac) topoView
+			Location startPosition = ((Ieee80211AdHocMac) topoView
 					.getMac(eventInfo.getReceiver())).getPosition();
-			Position targetPosition = this.getPosition();
+			Location targetPosition = this.getPosition();
 			double ackSnr = rateManager.calculateActuallySNR(startPosition,
 					targetPosition, eInfo.getAckMode(), txPowerDbm);
 			rateManager.reportDataOk(eventInfo.getReceiver(), ackSnr,

src/de/tud/kom/p2psim/impl/network/AbstractNetLayer.java

@@ -26,7 +26,6 @@ import java.util.List;
 import de.tud.kom.p2psim.api.analyzer.ConnectivityAnalyzer;
 import de.tud.kom.p2psim.api.analyzer.MessageAnalyzer.Reason;
 import de.tud.kom.p2psim.api.analyzer.NetlayerAnalyzer;
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.common.SimHost;
 import de.tud.kom.p2psim.api.linklayer.mac.PhyType;
 import de.tud.kom.p2psim.api.network.NetMessage;
@@ -42,6 +41,7 @@ import de.tudarmstadt.maki.simonstrator.api.component.core.MonitorComponent.Anal
 import de.tudarmstadt.maki.simonstrator.api.component.network.Bandwidth;
 import de.tudarmstadt.maki.simonstrator.api.component.network.NetID;
 import de.tudarmstadt.maki.simonstrator.api.component.network.NetInterface;
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
 import de.tudarmstadt.maki.simonstrator.api.component.transport.ConnectivityListener;
 
 /**
@@ -70,7 +70,7 @@ public abstract class AbstractNetLayer implements SimNetworkComponent,
 
 	private boolean online;
 
-	private Position position;
+	private Location position;
 
 	Bandwidth currentBandwidth;
 
@@ -93,7 +93,7 @@ public abstract class AbstractNetLayer implements SimNetworkComponent,
 	 *            the NetPosition of the network layer
 	 */
 	public AbstractNetLayer(SimHost host, NetID netId, Bandwidth maxBandwidth,
-			Position position, NetMeasurementDB.Host hostMeta) {
+			Location position, NetMeasurementDB.Host hostMeta) {
 		this.myID = netId;
 		this.msgListeners = new LinkedList<NetMessageListener>();
 		this.connListeners = new LinkedList<ConnectivityListener>();
@@ -378,7 +378,7 @@ public abstract class AbstractNetLayer implements SimNetworkComponent,
 	 * @see de.tud.kom.p2psim.api.api.network.NetLayer#getNetPosition()
 	 */
 	@Override
-	public Position getNetPosition() {
+	public Location getNetPosition() {
 		return this.position;
 	}
 

src/de/tud/kom/p2psim/impl/network/fairshareng/FairshareNode.java

-package de.tud.kom.p2psim.impl.network.fairshareng;
-
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-import de.tud.kom.p2psim.api.analyzer.MessageAnalyzer.Reason;
-import de.tud.kom.p2psim.api.common.Position;
-import de.tud.kom.p2psim.api.common.SimHost;
-import de.tud.kom.p2psim.api.network.BandwidthImpl;
-import de.tud.kom.p2psim.api.network.FlowBasedNetlayer;
-import de.tud.kom.p2psim.api.network.NetMessage;
-import de.tud.kom.p2psim.api.network.NetProtocol;
-import de.tud.kom.p2psim.api.transport.TransProtocol;
-import de.tud.kom.p2psim.impl.network.AbstractNetLayer;
-import de.tud.kom.p2psim.impl.network.IPv4Message;
-import de.tud.kom.p2psim.impl.network.modular.db.NetMeasurementDB;
-import de.tud.kom.p2psim.impl.transport.AbstractTransMessage;
-import de.tudarmstadt.maki.simonstrator.api.Message;
-import de.tudarmstadt.maki.simonstrator.api.Monitor;
-import de.tudarmstadt.maki.simonstrator.api.Monitor.Level;
-import de.tudarmstadt.maki.simonstrator.api.component.network.NetID;
-
-/**
- * The Class Node.
- */
-public class FairshareNode extends AbstractNetLayer implements
-		FlowBasedNetlayer {
-
-
-	/** The subnet. */
-	private final FairshareSubnet subnet;
-
-	/** The host queues. */
-	private final Map<FairshareNode, LinkedList<NetMessage>> hostQueues;
-
-	/** The Constant FLOAT_DELTA to correct Floats 9.999 to 10. */
-	private final static float FLOAT_DELTA = 1e-7f;
-
-	/** The hash code. */
-	private final int hashCode;
-
-	/**
-	 * Instantiates a new node.
-	 * @param netID
-	 * @param geoLoc
-	 */
-	public FairshareNode(SimHost host, FairshareSubnet subnet, NetID netID,
-			BandwidthImpl maxBandwidth, Position position,
-			NetMeasurementDB.Host hostMeta) {
-		super(host, netID, maxBandwidth, position, hostMeta);
-		this.subnet = subnet;
-
-		this.hostQueues = new LinkedHashMap<FairshareNode, LinkedList<NetMessage>>();
-
-		this.hashCode = this.getNetID().hashCode();
-	}
-
-	/**
-	 * Adds rate to the current down rate.
-	 * 
-	 * @param downRate
-	 * 
-	 *            the down rate
-	 * @throws Exception
-	 *             the exception
-	 */
-	public void addCurrentDownRate(double downRate) throws Exception {
-
-		final double currentDownBW = this.getCurrentBandwidth().getDownBW();
-		double realDownRate = currentDownBW - downRate;
-
-		/* Fix float, in case we get 9.999 save 10. */
-		if( Math.abs(Math.round(realDownRate) - realDownRate) < FLOAT_DELTA ) {
-			realDownRate = Math.round(realDownRate);
-		}
-
-		this.getCurrentBandwidth().setDownBW(realDownRate);
-
-	}
-
-	/**
-	 * Adds rate to the current up rate.
-	 * 
-	 * @param upRate
-	 *            the up rate
-	 * @throws Exception
-	 *             the exception
-	 */
-	public void addCurrentUpRate(double upRate) throws Exception {
-
-		final double currentUpBW = this.getCurrentBandwidth().getUpBW();
-		double realUpRate = currentUpBW - upRate;
-
-		/* Fix float, in case we get 9.999 save 10. */
-		if( Math.abs(Math.round(realUpRate) - realUpRate) < FLOAT_DELTA ) {
-			realUpRate = Math.round(realUpRate);
-		}
-
-		this.getCurrentBandwidth().setUpBW(realUpRate);
-
-	}
-
-
-	/**
-	 * Resets the node by setting current rates to zero.
-	 */
-	public void reset() {
-		this.setCurrentBandwidth(this.getMaxBandwidth().clone());
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see de.tud.kom.p2psim.impl.network.AbstractNetLayer#goOffline()
-	 */
-	@Override
-	public void goOffline() {
-		super.goOffline();
-		this.subnet.disconnectHost(this);
-	}
-
-
-	/* (non-Javadoc)
-	 * @see de.tud.kom.p2psim.api.network.NetLayer#send(de.tud.kom.p2psim.api.common.Message, de.tud.kom.p2psim.api.network.NetID, de.tud.kom.p2psim.api.network.NetProtocol)
-	 */
-	@Override
-	public void send(Message msg, NetID receiverId, NetProtocol protocol) {
-
-		if (isOnline()) {
-			assert (msg.getSize() >= 0);
-			assert (isSupported(((AbstractTransMessage) msg).getProtocol()));
-
-			final NetMessage netMsg = new IPv4Message(msg, receiverId, this.getNetID());
-			final TransProtocol tpMsg = ((AbstractTransMessage) msg).getProtocol();
-			if (tpMsg.equals(TransProtocol.UDP)) {
-
-				if (hasAnalyzer) {
-					netAnalyzerProxy
-							.netMsgEvent(netMsg, getHost(), Reason.SEND);
-				}
-				this.subnet.sendUDP(netMsg);
-
-			} else if (tpMsg.equals(TransProtocol.TCP)) {
-				final FairshareNode receiver = this.subnet.getNetLayer(receiverId);
-
-				LinkedList<NetMessage> queuedMessages = this.hostQueues.get(receiver);
-				if (queuedMessages == null) {
-					queuedMessages = new LinkedList<NetMessage>();
-					this.hostQueues.put(receiver, queuedMessages);
-				}
-
-				if (hasAnalyzer) {
-					netAnalyzerProxy
-							.netMsgEvent(netMsg, getHost(), Reason.SEND);
-				}
-				if (queuedMessages.isEmpty()) {
-
-					try {
-						this.subnet.sendTCPMessage(netMsg);
-					} catch (final Exception e) {
-
-						/*
-						 * Can't throw exception here as send(Message msg, NetID receiverId, NetProtocol protocol) is overwritten.
-						 */
-
-						Monitor.log(FairshareNode.class, Level.ERROR,
-								"Exception..: sendTCP failed. %s", e);
-						assert(false) : "sendTCP failed: " + e;
-
-					}
-
-				}
-				queuedMessages.add(netMsg);
-
-			} else {
-
-				/*
-				 * Can't throw exception here as send(Message msg, NetID receiverId, NetProtocol protocol) is overwritten.
-				 */
-				Monitor.log(FairshareNode.class, Level.ERROR,
-						"Unsupported transport protocol " + tpMsg);
-				assert (false) : "Unsupported transport protocol " + tpMsg;
-
-			}
-		} else {
-
-			Monitor.log(FairshareNode.class, Level.WARN, "Host " + this
-					+ " is offline.");
-
-		}
-
-	}
-
-	/* (non-Javadoc)
-	 * @see de.tud.kom.p2psim.impl.network.AbstractNetLayer#isSupported(de.tud.kom.p2psim.api.transport.TransProtocol)
-	 */
-	@Override
-	protected boolean isSupported(TransProtocol protocol) {
-		return (protocol.equals(TransProtocol.UDP) || protocol.equals(TransProtocol.TCP));
-	}
-
-	/**
-	 * Checks if message queue is empty.
-	 *
-	 * @param receiver the receiver
-	 * @return true, if is message queue empty
-	 */
-	public boolean isMessageQueueEmpty(FairshareNode receiver) {
-		return this.hostQueues.get(receiver).isEmpty();
-	}
-
-	/**
-	 * Peek message queue and return size of next expected arrival.
-	 *
-	 * @param receiver the receiver
-	 * @return the double
-	 */
-	public double peekMessageQueue(FairshareNode receiver) {
-		return this.hostQueues.get(receiver).get(0).getSize();
-	}
-
-	/**
-	 * Gets a read-only view on message queue.
-	 *
-	 * @param receiver the receiver
-	 * @return the view on message queue
-	 */
-	public List<NetMessage> getViewOnMessageQueue(FairshareNode receiver) {
-		return Collections.unmodifiableList(this.hostQueues.get(receiver));
-	}
-
-	/**
-	 * Removes the message from queue.
-	 *
-	 * @param receiver the receiver
-	 * @return the net message
-	 */
-	public NetMessage removeMessageFromQueue(FairshareNode receiver) {
-		return this.hostQueues.get(receiver).remove(0);
-	}
-	
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see java.lang.Object#equals(java.lang.Object)
-	 */
-	@Override
-	public boolean equals(Object obj) {
-		return (obj instanceof FairshareNode) ? ((FairshareNode) obj).getNetID().hashCode() == this.getNetID().hashCode() : super.equals(obj);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see java.lang.Object#toString()
-	 */
-	@Override
-	public String toString() {
-		return this.getLocalInetAddress() + " (U:"
-				+ this.getCurrentBandwidth().getUpBW() + "/D:"
-				+ this.getCurrentBandwidth().getDownBW() + ")";
-	}
-
-	/* (non-Javadoc)
-	 * @see java.lang.Object#hashCode()
-	 */
-	@Override
-	public int hashCode() {
-		/* Precomputed to save time. */
-		return this.hashCode;
-	}
-}
+package de.tud.kom.p2psim.impl.network.fairshareng;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import de.tud.kom.p2psim.api.analyzer.MessageAnalyzer.Reason;
+import de.tud.kom.p2psim.api.common.SimHost;
+import de.tud.kom.p2psim.api.network.BandwidthImpl;
+import de.tud.kom.p2psim.api.network.FlowBasedNetlayer;
+import de.tud.kom.p2psim.api.network.NetMessage;
+import de.tud.kom.p2psim.api.network.NetProtocol;
+import de.tud.kom.p2psim.api.transport.TransProtocol;
+import de.tud.kom.p2psim.impl.network.AbstractNetLayer;
+import de.tud.kom.p2psim.impl.network.IPv4Message;
+import de.tud.kom.p2psim.impl.network.modular.db.NetMeasurementDB;
+import de.tud.kom.p2psim.impl.transport.AbstractTransMessage;
+import de.tudarmstadt.maki.simonstrator.api.Message;
+import de.tudarmstadt.maki.simonstrator.api.Monitor;
+import de.tudarmstadt.maki.simonstrator.api.Monitor.Level;
+import de.tudarmstadt.maki.simonstrator.api.component.network.NetID;
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
+
+/**
+ * The Class Node.
+ */
+public class FairshareNode extends AbstractNetLayer implements
+		FlowBasedNetlayer {
+
+
+	/** The subnet. */
+	private final FairshareSubnet subnet;
+
+	/** The host queues. */
+	private final Map<FairshareNode, LinkedList<NetMessage>> hostQueues;
+
+	/** The Constant FLOAT_DELTA to correct Floats 9.999 to 10. */
+	private final static float FLOAT_DELTA = 1e-7f;
+
+	/** The hash code. */
+	private final int hashCode;
+
+	/**
+	 * Instantiates a new node.
+	 * @param netID
+	 * @param geoLoc
+	 */
+	public FairshareNode(SimHost host, FairshareSubnet subnet, NetID netID,
+			BandwidthImpl maxBandwidth, Location position,
+			NetMeasurementDB.Host hostMeta) {
+		super(host, netID, maxBandwidth, position, hostMeta);
+		this.subnet = subnet;
+
+		this.hostQueues = new LinkedHashMap<FairshareNode, LinkedList<NetMessage>>();
+
+		this.hashCode = this.getNetID().hashCode();
+	}
+
+	/**
+	 * Adds rate to the current down rate.
+	 * 
+	 * @param downRate
+	 * 
+	 *            the down rate
+	 * @throws Exception
+	 *             the exception
+	 */
+	public void addCurrentDownRate(double downRate) throws Exception {
+
+		final double currentDownBW = this.getCurrentBandwidth().getDownBW();
+		double realDownRate = currentDownBW - downRate;
+
+		/* Fix float, in case we get 9.999 save 10. */
+		if( Math.abs(Math.round(realDownRate) - realDownRate) < FLOAT_DELTA ) {
+			realDownRate = Math.round(realDownRate);
+		}
+
+		this.getCurrentBandwidth().setDownBW(realDownRate);
+
+	}
+
+	/**
+	 * Adds rate to the current up rate.
+	 * 
+	 * @param upRate
+	 *            the up rate
+	 * @throws Exception
+	 *             the exception
+	 */
+	public void addCurrentUpRate(double upRate) throws Exception {
+
+		final double currentUpBW = this.getCurrentBandwidth().getUpBW();
+		double realUpRate = currentUpBW - upRate;
+
+		/* Fix float, in case we get 9.999 save 10. */
+		if( Math.abs(Math.round(realUpRate) - realUpRate) < FLOAT_DELTA ) {
+			realUpRate = Math.round(realUpRate);
+		}
+
+		this.getCurrentBandwidth().setUpBW(realUpRate);
+
+	}
+
+
+	/**
+	 * Resets the node by setting current rates to zero.
+	 */
+	public void reset() {
+		this.setCurrentBandwidth(this.getMaxBandwidth().clone());
+	}
+	
+	
+	/* (non-Javadoc)
+	 * @see de.tud.kom.p2psim.impl.network.AbstractNetLayer#goOffline()
+	 */
+	@Override
+	public void goOffline() {
+		super.goOffline();
+		this.subnet.disconnectHost(this);
+	}
+
+
+	/* (non-Javadoc)
+	 * @see de.tud.kom.p2psim.api.network.NetLayer#send(de.tud.kom.p2psim.api.common.Message, de.tud.kom.p2psim.api.network.NetID, de.tud.kom.p2psim.api.network.NetProtocol)
+	 */
+	@Override
+	public void send(Message msg, NetID receiverId, NetProtocol protocol) {
+
+		if (isOnline()) {
+			assert (msg.getSize() >= 0);
+			assert (isSupported(((AbstractTransMessage) msg).getProtocol()));
+
+			final NetMessage netMsg = new IPv4Message(msg, receiverId, this.getNetID());
+			final TransProtocol tpMsg = ((AbstractTransMessage) msg).getProtocol();
+			if (tpMsg.equals(TransProtocol.UDP)) {
+
+				if (hasAnalyzer) {
+					netAnalyzerProxy
+							.netMsgEvent(netMsg, getHost(), Reason.SEND);
+				}
+				this.subnet.sendUDP(netMsg);
+
+			} else if (tpMsg.equals(TransProtocol.TCP)) {
+				final FairshareNode receiver = this.subnet.getNetLayer(receiverId);
+
+				LinkedList<NetMessage> queuedMessages = this.hostQueues.get(receiver);
+				if (queuedMessages == null) {
+					queuedMessages = new LinkedList<NetMessage>();
+					this.hostQueues.put(receiver, queuedMessages);
+				}
+
+				if (hasAnalyzer) {
+					netAnalyzerProxy
+							.netMsgEvent(netMsg, getHost(), Reason.SEND);
+				}
+				if (queuedMessages.isEmpty()) {
+
+					try {
+						this.subnet.sendTCPMessage(netMsg);
+					} catch (final Exception e) {
+
+						/*
+						 * Can't throw exception here as send(Message msg, NetID receiverId, NetProtocol protocol) is overwritten.
+						 */
+
+						Monitor.log(FairshareNode.class, Level.ERROR,
+								"Exception..: sendTCP failed. %s", e);
+						assert(false) : "sendTCP failed: " + e;
+
+					}
+
+				}
+				queuedMessages.add(netMsg);
+
+			} else {
+
+				/*
+				 * Can't throw exception here as send(Message msg, NetID receiverId, NetProtocol protocol) is overwritten.
+				 */
+				Monitor.log(FairshareNode.class, Level.ERROR,
+						"Unsupported transport protocol " + tpMsg);
+				assert (false) : "Unsupported transport protocol " + tpMsg;
+
+			}
+		} else {
+
+			Monitor.log(FairshareNode.class, Level.WARN, "Host " + this
+					+ " is offline.");
+
+		}
+
+	}
+
+	/* (non-Javadoc)
+	 * @see de.tud.kom.p2psim.impl.network.AbstractNetLayer#isSupported(de.tud.kom.p2psim.api.transport.TransProtocol)
+	 */
+	@Override
+	protected boolean isSupported(TransProtocol protocol) {
+		return (protocol.equals(TransProtocol.UDP) || protocol.equals(TransProtocol.TCP));
+	}
+
+	/**
+	 * Checks if message queue is empty.
+	 *
+	 * @param receiver the receiver
+	 * @return true, if is message queue empty
+	 */
+	public boolean isMessageQueueEmpty(FairshareNode receiver) {
+		return this.hostQueues.get(receiver).isEmpty();
+	}
+
+	/**
+	 * Peek message queue and return size of next expected arrival.
+	 *
+	 * @param receiver the receiver
+	 * @return the double
+	 */
+	public double peekMessageQueue(FairshareNode receiver) {
+		return this.hostQueues.get(receiver).get(0).getSize();
+	}
+
+	/**
+	 * Gets a read-only view on message queue.
+	 *
+	 * @param receiver the receiver
+	 * @return the view on message queue
+	 */
+	public List<NetMessage> getViewOnMessageQueue(FairshareNode receiver) {
+		return Collections.unmodifiableList(this.hostQueues.get(receiver));
+	}
+
+	/**
+	 * Removes the message from queue.
+	 *
+	 * @param receiver the receiver
+	 * @return the net message
+	 */
+	public NetMessage removeMessageFromQueue(FairshareNode receiver) {
+		return this.hostQueues.get(receiver).remove(0);
+	}
+	
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#equals(java.lang.Object)
+	 */
+	@Override
+	public boolean equals(Object obj) {
+		return (obj instanceof FairshareNode) ? ((FairshareNode) obj).getNetID().hashCode() == this.getNetID().hashCode() : super.equals(obj);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
+	@Override
+	public String toString() {
+		return this.getLocalInetAddress() + " (U:"
+				+ this.getCurrentBandwidth().getUpBW() + "/D:"
+				+ this.getCurrentBandwidth().getDownBW() + ")";
+	}
+
+	/* (non-Javadoc)
+	 * @see java.lang.Object#hashCode()
+	 */
+	@Override
+	public int hashCode() {
+		/* Precomputed to save time. */
+		return this.hashCode;
+	}
+}

src/de/tud/kom/p2psim/impl/network/gnp/GnpLatencyModel.java

@@ -19,12 +19,10 @@
  */
 
 
-package de.tud.kom.p2psim.impl.network.gnp;
-
+package de.tud.kom.p2psim.impl.network.gnp;
+
 import java.util.Random;
 
-import umontreal.iro.lecuyer.probdist.LognormalDist;
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.linklayer.mac.PhyType;
 import de.tud.kom.p2psim.api.network.NetLatencyModel;
 import de.tud.kom.p2psim.api.network.NetLayer;
@@ -35,133 +33,135 @@ import de.tud.kom.p2psim.impl.network.gnp.topology.CountryLookup;
 import de.tud.kom.p2psim.impl.network.gnp.topology.PingErLookup;
 import de.tudarmstadt.maki.simonstrator.api.Randoms;
 import de.tudarmstadt.maki.simonstrator.api.Time;
-
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
+import umontreal.iro.lecuyer.probdist.LognormalDist;
+
 public class GnpLatencyModel implements NetLatencyModel {
 
-	private Random rnd = Randoms.getRandom(GnpLatencyModel.class);
-
+	private Random rnd = Randoms.getRandom(GnpLatencyModel.class);
+
 	public static final int MSS = PhyType.ETHERNET.getDefaultMTU()
 			- NetProtocol.IPv4.getHeaderSize()
-			- TransProtocol.TCP.getHeaderSize();
-
-	private static PingErLookup pingErLookup;
-
-	private static CountryLookup countryLookup;
-
-	private boolean usePingErInsteadOfGnp = false;
-
-	private boolean useAnalyticalFunctionInsteadOfGnp = false;
-
-	private boolean usePingErJitter = false;
-
-	private boolean usePingErPacketLoss = false;
-
-	public void init(PingErLookup pingErLookup, CountryLookup countryLookup) {
-		GnpLatencyModel.pingErLookup = pingErLookup;
-		GnpLatencyModel.countryLookup = countryLookup;
-	}
-
-	private double getMinimumRTT(GnpNetLayer sender, GnpNetLayer receiver) {
-		String ccSender = sender.getCountryCode();
-		String ccReceiver = receiver.getCountryCode();
-		double minRtt = 0.0;
-		if (usePingErInsteadOfGnp) {
-			minRtt = pingErLookup.getMinimumRtt(ccSender, ccReceiver, countryLookup);
-		} else if (useAnalyticalFunctionInsteadOfGnp) {
-			double distance = GeoLocationOracle.getGeographicalDistance(sender.getNetID(), receiver.getNetID());
-			minRtt = 62 + (0.02 * distance);
-		} else {
-			Position senderPos = sender.getNetPosition();
-			Position receiverPos = receiver.getNetPosition();
-			minRtt = senderPos.getDistance(receiverPos);
-		}
-		return minRtt;
-	}
-
-	private double getPacketLossProbability(GnpNetLayer sender, GnpNetLayer receiver) {
-		String ccSender = sender.getCountryCode();
-		String ccReceiver = receiver.getCountryCode();
-		double twoWayLossRate = 0.0;
-		double oneWayLossRate = 0.0;
-		if (usePingErPacketLoss) {
-			twoWayLossRate = pingErLookup.getPacktLossRate(ccSender, ccReceiver, countryLookup);
-			twoWayLossRate /= 100;
-			oneWayLossRate = 1 - Math.sqrt(1 - twoWayLossRate);
-		}
-		return oneWayLossRate;
-
-	}
-
-	private double getNextJitter(GnpNetLayer sender, GnpNetLayer receiver) {
-		String ccSender = sender.getCountryCode();
-		String ccReceiver = receiver.getCountryCode();
-		double randomJitter = 0.0;
-		if (usePingErJitter) {
-			LognormalDist distri = pingErLookup.getJitterDistribution(ccSender, ccReceiver, countryLookup);
-			randomJitter = distri.inverseF(rnd.nextDouble());
-		}
-		return randomJitter;
-
-	}
-
-	private double getAverageJitter(GnpNetLayer sender, GnpNetLayer receiver) {
-		String ccSender = sender.getCountryCode();
-		String ccReceiver = receiver.getCountryCode();
-		double jitter = 0.0;
-		if (usePingErJitter) {
-			jitter = pingErLookup.getAverageRtt(ccSender, ccReceiver, countryLookup) - pingErLookup.getMinimumRtt(ccSender, ccReceiver, countryLookup);
-		}
-		return jitter;
-	}
-
-	public double getUDPerrorProbability(GnpNetLayer sender, GnpNetLayer receiver, IPv4Message msg) {
-		if (msg.getPayload().getSize() > 65507)
-			throw new IllegalArgumentException("Message-Size ist too big for a UDP-Datagramm (max 65507 byte)");
-		double lp = getPacketLossProbability(sender, receiver);
-		double errorProb = 1 - Math.pow(1 - lp, msg.getNoOfFragments());
-		return errorProb;
-	}
-
-	public double getTcpThroughput(GnpNetLayer sender, GnpNetLayer receiver) {
-		double minRtt = getMinimumRTT(sender, receiver);
-		double averageJitter = getAverageJitter(sender, receiver);
-		double packetLossRate = getPacketLossProbability(sender, receiver);
-		double mathisBW = ((MSS * 1000) / (minRtt + averageJitter)) * Math.sqrt(1.5 / packetLossRate);
-		return mathisBW;
-	}
-
-	public long getTransmissionDelay(double bytes, double bandwidth) {
-		double messageTime = bytes / bandwidth;
-		long delay = Math.round((messageTime * Time.SECOND));
-		return delay;
-	}
-
-	public long getPropagationDelay(GnpNetLayer sender, GnpNetLayer receiver) {
-		double minRtt = getMinimumRTT(sender, receiver);
-		double randomJitter = getNextJitter(sender, receiver);
-		double receiveTime = (minRtt + randomJitter) / 2.0;
-		long latency = Math.round(receiveTime * Time.MILLISECOND);
-		return latency;
-	}
-
-	public long getLatency(NetLayer sender, NetLayer receiver) {
-		return getPropagationDelay((GnpNetLayer) sender, (GnpNetLayer) receiver);
-	}
-
-	public void setUsePingErRttData(boolean pingErRtt) {
-		usePingErInsteadOfGnp = pingErRtt;
-	}
-
-	public void setUseAnalyticalRtt(boolean analyticalRtt) {
-		useAnalyticalFunctionInsteadOfGnp = analyticalRtt;
-	}
-
-	public void setUsePingErJitter(boolean pingErRtt) {
-		usePingErJitter = pingErRtt;
-	}
-
-	public void setUsePingErPacketLoss(boolean pingErPacketLoss) {
-		usePingErPacketLoss = pingErPacketLoss;
-	}
-
+			- TransProtocol.TCP.getHeaderSize();
+
+	private static PingErLookup pingErLookup;
+
+	private static CountryLookup countryLookup;
+
+	private boolean usePingErInsteadOfGnp = false;
+
+	private boolean useAnalyticalFunctionInsteadOfGnp = false;
+
+	private boolean usePingErJitter = false;
+
+	private boolean usePingErPacketLoss = false;
+
+	public void init(PingErLookup pingErLookup, CountryLookup countryLookup) {
+		GnpLatencyModel.pingErLookup = pingErLookup;
+		GnpLatencyModel.countryLookup = countryLookup;
+	}
+
+	private double getMinimumRTT(GnpNetLayer sender, GnpNetLayer receiver) {
+		String ccSender = sender.getCountryCode();
+		String ccReceiver = receiver.getCountryCode();
+		double minRtt = 0.0;
+		if (usePingErInsteadOfGnp) {
+			minRtt = pingErLookup.getMinimumRtt(ccSender, ccReceiver, countryLookup);
+		} else if (useAnalyticalFunctionInsteadOfGnp) {
+			double distance = GeoLocationOracle.getGeographicalDistance(sender.getNetID(), receiver.getNetID());
+			minRtt = 62 + (0.02 * distance);
+		} else {
+			Location senderPos = sender.getNetPosition();
+			Location receiverPos = receiver.getNetPosition();
+			minRtt = senderPos.distanceTo(receiverPos);
+		}
+		return minRtt;
+	}
+
+	private double getPacketLossProbability(GnpNetLayer sender, GnpNetLayer receiver) {
+		String ccSender = sender.getCountryCode();
+		String ccReceiver = receiver.getCountryCode();
+		double twoWayLossRate = 0.0;
+		double oneWayLossRate = 0.0;
+		if (usePingErPacketLoss) {
+			twoWayLossRate = pingErLookup.getPacktLossRate(ccSender, ccReceiver, countryLookup);
+			twoWayLossRate /= 100;
+			oneWayLossRate = 1 - Math.sqrt(1 - twoWayLossRate);
+		}
+		return oneWayLossRate;
+
+	}
+
+	private double getNextJitter(GnpNetLayer sender, GnpNetLayer receiver) {
+		String ccSender = sender.getCountryCode();
+		String ccReceiver = receiver.getCountryCode();
+		double randomJitter = 0.0;
+		if (usePingErJitter) {
+			LognormalDist distri = pingErLookup.getJitterDistribution(ccSender, ccReceiver, countryLookup);
+			randomJitter = distri.inverseF(rnd.nextDouble());
+		}
+		return randomJitter;
+
+	}
+
+	private double getAverageJitter(GnpNetLayer sender, GnpNetLayer receiver) {
+		String ccSender = sender.getCountryCode();
+		String ccReceiver = receiver.getCountryCode();
+		double jitter = 0.0;
+		if (usePingErJitter) {
+			jitter = pingErLookup.getAverageRtt(ccSender, ccReceiver, countryLookup) - pingErLookup.getMinimumRtt(ccSender, ccReceiver, countryLookup);
+		}
+		return jitter;
+	}
+
+	public double getUDPerrorProbability(GnpNetLayer sender, GnpNetLayer receiver, IPv4Message msg) {
+		if (msg.getPayload().getSize() > 65507)
+			throw new IllegalArgumentException("Message-Size ist too big for a UDP-Datagramm (max 65507 byte)");
+		double lp = getPacketLossProbability(sender, receiver);
+		double errorProb = 1 - Math.pow(1 - lp, msg.getNoOfFragments());
+		return errorProb;
+	}
+
+	public double getTcpThroughput(GnpNetLayer sender, GnpNetLayer receiver) {
+		double minRtt = getMinimumRTT(sender, receiver);
+		double averageJitter = getAverageJitter(sender, receiver);
+		double packetLossRate = getPacketLossProbability(sender, receiver);
+		double mathisBW = ((MSS * 1000) / (minRtt + averageJitter)) * Math.sqrt(1.5 / packetLossRate);
+		return mathisBW;
+	}
+
+	public long getTransmissionDelay(double bytes, double bandwidth) {
+		double messageTime = bytes / bandwidth;
+		long delay = Math.round((messageTime * Time.SECOND));
+		return delay;
+	}
+
+	public long getPropagationDelay(GnpNetLayer sender, GnpNetLayer receiver) {
+		double minRtt = getMinimumRTT(sender, receiver);
+		double randomJitter = getNextJitter(sender, receiver);
+		double receiveTime = (minRtt + randomJitter) / 2.0;
+		long latency = Math.round(receiveTime * Time.MILLISECOND);
+		return latency;
+	}
+
+	public long getLatency(NetLayer sender, NetLayer receiver) {
+		return getPropagationDelay((GnpNetLayer) sender, (GnpNetLayer) receiver);
+	}
+
+	public void setUsePingErRttData(boolean pingErRtt) {
+		usePingErInsteadOfGnp = pingErRtt;
+	}
+
+	public void setUseAnalyticalRtt(boolean analyticalRtt) {
+		useAnalyticalFunctionInsteadOfGnp = analyticalRtt;
+	}
+
+	public void setUsePingErJitter(boolean pingErRtt) {
+		usePingErJitter = pingErRtt;
+	}
+
+	public void setUsePingErPacketLoss(boolean pingErPacketLoss) {
+		usePingErPacketLoss = pingErPacketLoss;
+	}
+
 }
\ No newline at end of file

src/de/tud/kom/p2psim/impl/network/gnp/topology/GeographicPosition.java

@@ -19,59 +19,53 @@
  */
 
 
-package de.tud.kom.p2psim.impl.network.gnp.topology;
-
+package de.tud.kom.p2psim.impl.network.gnp.topology;
+
 
 
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.impl.topology.PositionVector;
-
-/**
- * Implementation of NetPosition for Position and distance measurnment on the
- * earth.
- * 
- * @author Gerald Klunker
- * @version 0.1, 05.02.2008
- * 
- */
-
-public class GeographicPosition extends PositionVector {
-
-	private double latitude;
-
-	private double longitude;
-
-	/**
-	 * 
-	 * @param longitude
-	 * @param latitude
-	 */
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
+
+/**
+ * Implementation of NetPosition for Position and distance measurnment on the
+ * earth.
+ * 
+ * @author Gerald Klunker
+ * @version 0.1, 05.02.2008
+ * 
+ */
+
+public class GeographicPosition extends PositionVector {
+
+	private double latitude;
+
+	private double longitude;
+
+	/**
+	 * 
+	 * @param longitude
+	 * @param latitude
+	 */
 	public GeographicPosition(double longitude, double latitude) {
-		super(new double[] { longitude, latitude });
-		this.longitude = longitude;
-		this.latitude = latitude;
-	}
-
-	/**
-	 * @return geographical distance in km
-	 */
-	public double getDistance(Position point) {
-		double pi = 3.14159265;
-		double radConverter = pi / 180;
-		double lat1 = latitude * radConverter;
-		double lat2 = ((GeographicPosition) point).getLatitude() * radConverter;
-		double delta_lat = lat2 - lat1;
-		double delta_lon = (((GeographicPosition) point).getLongitude() - longitude)
-				* radConverter;
-		double temp = Math.pow(Math.sin(delta_lat / 2), 2) + Math.cos(lat1)
-				* Math.cos(lat2) * Math.pow(Math.sin(delta_lon / 2), 2);
-		return 2 * 6378.2 * Math.atan2(Math.sqrt(temp), Math.sqrt(1 - temp));
+		super(new double[] { longitude, latitude });
+		this.longitude = longitude;
+		this.latitude = latitude;
 	}
 
-	@Override
-	public double getAngle(Position target) {
-		throw new AssertionError(
-				"getAngle is not defined for this Position-Type");
+	/**
+	 * @return geographical distance in km
+	 */
+	public double distanceTo(Location point) {
+		double pi = 3.14159265;
+		double radConverter = pi / 180;
+		double lat1 = latitude * radConverter;
+		double lat2 = ((GeographicPosition) point).getLatitude() * radConverter;
+		double delta_lat = lat2 - lat1;
+		double delta_lon = (((GeographicPosition) point).getLongitude() - longitude)
+				* radConverter;
+		double temp = Math.pow(Math.sin(delta_lat / 2), 2) + Math.cos(lat1)
+				* Math.cos(lat2) * Math.pow(Math.sin(delta_lon / 2), 2);
+		return 2 * 6378.2 * Math.atan2(Math.sqrt(temp), Math.sqrt(1 - temp));
 	}
 
 	@Override
@@ -81,22 +75,22 @@ public class GeographicPosition extends PositionVector {
 
 	public GeographicPosition clone() {
 		return new GeographicPosition(longitude, latitude);
-	}
-
-	/**
-	 * 
-	 * @return latitude of position
-	 */
-	public double getLatitude() {
-		return latitude;
-	}
-
-	/**
-	 * 
-	 * @return longitude of position
-	 */
-	public double getLongitude() {
-		return longitude;
-	}
-
-}
+	}
+
+	/**
+	 * 
+	 * @return latitude of position
+	 */
+	public double getLatitude() {
+		return latitude;
+	}
+
+	/**
+	 * 
+	 * @return longitude of position
+	 */
+	public double getLongitude() {
+		return longitude;
+	}
+
+}

src/de/tud/kom/p2psim/impl/network/gnp/topology/GnpPosition.java

@@ -19,296 +19,283 @@
  */
 
 
-package de.tud.kom.p2psim.impl.network.gnp.topology;
-
+package de.tud.kom.p2psim.impl.network.gnp.topology;
+
 import java.util.ArrayList;
 
-import de.tud.kom.p2psim.api.common.Position;
 import de.tudarmstadt.maki.simonstrator.api.Randoms;
 import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
-
-/**
- * This class implements a NetPosition for a GNP-Based calculation of round trip
- * times. Therefore it includes methods for error estimation and methods for
- * positioning by a downhill simplex algorithm in the GnpSpace class
- * 
- * @author Gerald Klunker
- * @version 0.1, 09.01.2008
- * 
- */
 
-public class GnpPosition implements Position, Comparable<GnpPosition> {
-
-	private static final long serialVersionUID = -1103996725403557900L;
-
-	private double[] gnpCoordinates;
-
-	private GnpSpace gnpRef;
-
-	private Host hostRef;
-
-	private double error = -1.0;
-
-	/**
-	 * 
-	 * @param gnpCoordinates
-	 *            coordinate array for new position
-	 */
-	public GnpPosition(double[] gnpCoordinates) {
-		super();
-		this.gnpCoordinates = gnpCoordinates;
-	}
-
-	/**
-	 * Object will be initialized with a random position. Position must be
-	 * random according to the downhill simplex
-	 * 
-	 * @param noOfDimensions
-	 *            number of dimensions
-	 * @param hostRef
-	 *            related Host object
-	 * @param gnpRef
-	 *            related GnpSpace object
-	 */
-	public GnpPosition(int noOfDimensions, Host hostRef, GnpSpace gnpRef) {
-		super();
-		gnpCoordinates = new double[noOfDimensions];
-		this.hostRef = hostRef;
-		this.gnpRef = gnpRef;
-		for (int c = 0; c < gnpCoordinates.length; c++)
+/**
+ * This class implements a NetPosition for a GNP-Based calculation of round trip
+ * times. Therefore it includes methods for error estimation and methods for
+ * positioning by a downhill simplex algorithm in the GnpSpace class
+ * 
+ * @author Gerald Klunker
+ * @version 0.1, 09.01.2008
+ * 
+ */
+
+public class GnpPosition implements Location, Comparable<GnpPosition> {
+
+	private static final long serialVersionUID = -1103996725403557900L;
+
+	private double[] gnpCoordinates;
+
+	private GnpSpace gnpRef;
+
+	private Host hostRef;
+
+	private double error = -1.0;
+
+	/**
+	 * 
+	 * @param gnpCoordinates
+	 *            coordinate array for new position
+	 */
+	public GnpPosition(double[] gnpCoordinates) {
+		super();
+		this.gnpCoordinates = gnpCoordinates;
+	}
+
+	/**
+	 * Object will be initialized with a random position. Position must be
+	 * random according to the downhill simplex
+	 * 
+	 * @param noOfDimensions
+	 *            number of dimensions
+	 * @param hostRef
+	 *            related Host object
+	 * @param gnpRef
+	 *            related GnpSpace object
+	 */
+	public GnpPosition(int noOfDimensions, Host hostRef, GnpSpace gnpRef) {
+		super();
+		gnpCoordinates = new double[noOfDimensions];
+		this.hostRef = hostRef;
+		this.gnpRef = gnpRef;
+		for (int c = 0; c < gnpCoordinates.length; c++)
 			gnpCoordinates[c] = Randoms.getRandom(GnpPosition.class)
-					.nextDouble();
-	}
-
-	/**
-	 * 
-	 * @param dimension
-	 * @param maxDiversity
-	 */
-	public void diversify(double[][] dimension, double maxDiversity) {
-		for (int c = 0; c < this.gnpCoordinates.length; c++) {
-			double rand = (2 * maxDiversity * Math.random()) - maxDiversity;
-			gnpCoordinates[c] = gnpCoordinates[c] + (rand * dimension[c][2]);
-		}
-		error = -1.0;
-	}
-
-	/**
-	 * reposition
-	 * 
-	 * @param pos
-	 *            position in the coordinate array
-	 * @param value
-	 *            new value at position pos
-	 */
-	public void setGnpCoordinates(int pos, double value) {
-		gnpCoordinates[pos] = value;
-		error = -1.0;
-	}
-
-	/**
-	 * 
-	 * @return the related GnpSpace object
-	 */
-	private GnpSpace getGnpRef() {
-		return gnpRef;
-	}
-
-	/**
-	 * 
-	 * @return the related Host object
-	 */
-	public Host getHostRef() {
-		return hostRef;
-	}
-
-	/**
-	 * 
-	 * @return number of dimensions
-	 */
-	public int getNoOfDimensions() {
-		return gnpCoordinates.length;
-	}
-
-	/**
-	 * 
-	 * @param pos
-	 *            position in the coordinate array
-	 * @return value at position pos
-	 */
-	public double getGnpCoordinates(int pos) {
-		return gnpCoordinates[pos];
-	}
-
-	/**
-	 * Calculates the sum of all errors according to the downhill simplex
-	 * operator.
-	 * 
-	 * @return error
-	 */
-	public double getDownhillSimplexError() {
-		if (error < 0.0) {
-			error = 0.0;
-			for (int c = 0; c < getGnpRef().getNumberOfMonitors(); c++) {
-				error += getDownhillSimplexError(getGnpRef()
-						.getMonitorPosition(c));
-			}
-		}
-		return error;
-	}
-
-	/**
-	 * Calculates the error to a monitor according to the downhill simplex
-	 * operator
-	 * 
-	 * @param monitor
-	 * @return error
-	 */
-	public double getDownhillSimplexError(GnpPosition monitor) {
-		double calculatedDistance = this.getDistance(monitor);
-		double measuredDistance = this.getMeasuredRtt(monitor);
-		if (Double.compare(measuredDistance, Double.NaN) == 0)
-			return 0.0;
-		double error = Math.pow((calculatedDistance - measuredDistance)
-				/ calculatedDistance, 2);
-		return error;
-	}
-
-	/**
-	 * Calculates an error, that indicates the deviation of the measured vs. the
-	 * calculated rtt.
-	 * 
-	 * @param monitor
-	 * @return error value
-	 */
-	public double getDirectionalRelativError(GnpPosition monitor) {
-		double calculatedDistance = this.getDistance(monitor);
-		double measuredDistance = this.getMeasuredRtt(monitor);
-		if (Double.compare(measuredDistance, Double.NaN) == 0)
-			return Double.NaN;
-		double error = (calculatedDistance - measuredDistance)
-				/ Math.min(calculatedDistance, measuredDistance);
-		return error;
-	}
-
-	/**
-	 * Method must be overwrite to sort different GnpPositions in order of their
-	 * quality.
-	 * 
-	 * Is needed for the positioning with the downhill simplex
-	 * 
-	 */
-	public int compareTo(GnpPosition arg0) {
-		double val1 = this.getDownhillSimplexError();
-		double val2 = arg0.getDownhillSimplexError();
-		if (val1 < val2)
-			return -1;
-		if (val1 > val2)
-			return 1;
-		else
-			return 0;
-	}
-
-	/**
-	 * 
-	 * @return Comma-separated list of coordinates
-	 */
-	public String getCoordinateString() {
-		if (gnpCoordinates.length == 0) {
-			return "";
-		} else {
-			String result = String.valueOf(gnpCoordinates[0]);
-			for (int c = 1; c < gnpCoordinates.length; c++)
-				result = result + "," + gnpCoordinates[c];
-			return result;
-		}
-	}
-
-	/**
-	 * 
-	 * @param monitor
-	 * @return measured rtt to monitor, nan if no rtt was measured
-	 */
-	public double getMeasuredRtt(GnpPosition monitor) {
-		return this.getHostRef().getRtt(monitor.getHostRef());
-	}
-
-	/**
-	 * @return euclidean distance
-	 */
-	public double getDistance(Position point) {
-		GnpPosition coord = (GnpPosition) point;
-		double distance = 0.0;
-		for (int c = 0; c < gnpCoordinates.length; c++)
-			distance += Math.pow(
-					gnpCoordinates[c] - coord.getGnpCoordinates(c), 2);
-		return Math.sqrt(distance);
+					.nextDouble();
 	}
 
-	@Override
-	public double getAngle(Position target) {
-		throw new AssertionError(
-				"getAngle is not defined for this Position-Type");
+	/**
+	 * 
+	 * @param dimension
+	 * @param maxDiversity
+	 */
+	public void diversify(double[][] dimension, double maxDiversity) {
+		for (int c = 0; c < this.gnpCoordinates.length; c++) {
+			double rand = (2 * maxDiversity * Math.random()) - maxDiversity;
+			gnpCoordinates[c] = gnpCoordinates[c] + (rand * dimension[c][2]);
+		}
+		error = -1.0;
 	}
 
-	@Override
-	public Position getTarget(double distance, double angle) {
-		throw new AssertionError(
-				"getTarget is not defined for this Position-Type");
-	}
+	/**
+	 * reposition
+	 * 
+	 * @param pos
+	 *            position in the coordinate array
+	 * @param value
+	 *            new value at position pos
+	 */
+	public void setGnpCoordinates(int pos, double value) {
+		gnpCoordinates[pos] = value;
+		error = -1.0;
+	}
+
+	/**
+	 * 
+	 * @return the related GnpSpace object
+	 */
+	private GnpSpace getGnpRef() {
+		return gnpRef;
+	}
+
+	/**
+	 * 
+	 * @return the related Host object
+	 */
+	public Host getHostRef() {
+		return hostRef;
+	}
+
+	/**
+	 * 
+	 * @return number of dimensions
+	 */
+	public int getNoOfDimensions() {
+		return gnpCoordinates.length;
+	}
+
+	/**
+	 * 
+	 * @param pos
+	 *            position in the coordinate array
+	 * @return value at position pos
+	 */
+	public double getGnpCoordinates(int pos) {
+		return gnpCoordinates[pos];
+	}
+
+	/**
+	 * Calculates the sum of all errors according to the downhill simplex
+	 * operator.
+	 * 
+	 * @return error
+	 */
+	public double getDownhillSimplexError() {
+		if (error < 0.0) {
+			error = 0.0;
+			for (int c = 0; c < getGnpRef().getNumberOfMonitors(); c++) {
+				error += getDownhillSimplexError(getGnpRef()
+						.getMonitorPosition(c));
+			}
+		}
+		return error;
+	}
+
+	/**
+	 * Calculates the error to a monitor according to the downhill simplex
+	 * operator
+	 * 
+	 * @param monitor
+	 * @return error
+	 */
+	public double getDownhillSimplexError(GnpPosition monitor) {
+		double calculatedDistance = this.distanceTo(monitor);
+		double measuredDistance = this.getMeasuredRtt(monitor);
+		if (Double.compare(measuredDistance, Double.NaN) == 0)
+			return 0.0;
+		double error = Math.pow((calculatedDistance - measuredDistance)
+				/ calculatedDistance, 2);
+		return error;
+	}
+
+	/**
+	 * Calculates an error, that indicates the deviation of the measured vs. the
+	 * calculated rtt.
+	 * 
+	 * @param monitor
+	 * @return error value
+	 */
+	public double getDirectionalRelativError(GnpPosition monitor) {
+		double calculatedDistance = this.distanceTo(monitor);
+		double measuredDistance = this.getMeasuredRtt(monitor);
+		if (Double.compare(measuredDistance, Double.NaN) == 0)
+			return Double.NaN;
+		double error = (calculatedDistance - measuredDistance)
+				/ Math.min(calculatedDistance, measuredDistance);
+		return error;
+	}
+
+	/**
+	 * Method must be overwrite to sort different GnpPositions in order of their
+	 * quality.
+	 * 
+	 * Is needed for the positioning with the downhill simplex
+	 * 
+	 */
+	public int compareTo(GnpPosition arg0) {
+		double val1 = this.getDownhillSimplexError();
+		double val2 = arg0.getDownhillSimplexError();
+		if (val1 < val2)
+			return -1;
+		if (val1 > val2)
+			return 1;
+		else
+			return 0;
+	}
+
+	/**
+	 * 
+	 * @return Comma-separated list of coordinates
+	 */
+	public String getCoordinateString() {
+		if (gnpCoordinates.length == 0) {
+			return "";
+		} else {
+			String result = String.valueOf(gnpCoordinates[0]);
+			for (int c = 1; c < gnpCoordinates.length; c++)
+				result = result + "," + gnpCoordinates[c];
+			return result;
+		}
+	}
+
+	/**
+	 * 
+	 * @param monitor
+	 * @return measured rtt to monitor, nan if no rtt was measured
+	 */
+	public double getMeasuredRtt(GnpPosition monitor) {
+		return this.getHostRef().getRtt(monitor.getHostRef());
+	}
+
+	/**
+	 * @return euclidean distance
+	 */
+	public double getDistance(Location point) {
+		GnpPosition coord = (GnpPosition) point;
+		double distance = 0.0;
+		for (int c = 0; c < gnpCoordinates.length; c++)
+			distance += Math.pow(
+					gnpCoordinates[c] - coord.getGnpCoordinates(c), 2);
+		return Math.sqrt(distance);
+	}
 
 	@Override
 	public int getTransmissionSize() {
 		return 16; // 2 * double
 	}
-
-	/**
-	 * Static method generates a new GnpPosition according to the downhill
-	 * simplex operator
-	 * 
-	 * @param solution
-	 * @param moveToSolution
-	 * @param moveFactor
-	 * @return new position
-	 */
-	public static GnpPosition getMovedSolution(GnpPosition solution,
-			GnpPosition moveToSolution, double moveFactor) {
-		GnpPosition returnValue = new GnpPosition(solution.getNoOfDimensions(),
-				solution.getHostRef(), solution.getGnpRef());
-		for (int c = 0; c < solution.getNoOfDimensions(); c++) {
-			double newCoord = (moveToSolution.getGnpCoordinates(c) - solution
-					.getGnpCoordinates(c))
-					* moveFactor + solution.getGnpCoordinates(c);
-			returnValue.setGnpCoordinates(c, newCoord);
-		}
-		return returnValue;
-	}
-
-	/**
-	 * Static method generates a new GnpPosition according to the downhill
-	 * simplex operator
-	 * 
-	 * @param solution
-	 * @param moveToSolution
-	 * @param moveFactor
-	 * @return new position
-	 */
-	public static GnpPosition getCenterSolution(ArrayList<GnpPosition> solutions) {
-		GnpPosition returnValue = new GnpPosition(solutions.get(0)
-				.getNoOfDimensions(), solutions.get(0).getHostRef(), solutions
-				.get(0).getGnpRef());
-		for (int d = 0; d < solutions.size(); d++) {
-			for (int c = 0; c < solutions.get(0).getNoOfDimensions(); c++) {
-				returnValue.setGnpCoordinates(c, returnValue
-						.getGnpCoordinates(c)
-						+ solutions.get(d).getGnpCoordinates(c));
-			}
-		}
-		for (int c = 0; c < returnValue.getNoOfDimensions(); c++) {
-			returnValue.setGnpCoordinates(c, returnValue.getGnpCoordinates(c)
-					/ solutions.size());
-		}
-		return returnValue;
+
+	/**
+	 * Static method generates a new GnpPosition according to the downhill
+	 * simplex operator
+	 * 
+	 * @param solution
+	 * @param moveToSolution
+	 * @param moveFactor
+	 * @return new position
+	 */
+	public static GnpPosition getMovedSolution(GnpPosition solution,
+			GnpPosition moveToSolution, double moveFactor) {
+		GnpPosition returnValue = new GnpPosition(solution.getNoOfDimensions(),
+				solution.getHostRef(), solution.getGnpRef());
+		for (int c = 0; c < solution.getNoOfDimensions(); c++) {
+			double newCoord = (moveToSolution.getGnpCoordinates(c) - solution
+					.getGnpCoordinates(c))
+					* moveFactor + solution.getGnpCoordinates(c);
+			returnValue.setGnpCoordinates(c, newCoord);
+		}
+		return returnValue;
+	}
+
+	/**
+	 * Static method generates a new GnpPosition according to the downhill
+	 * simplex operator
+	 * 
+	 * @param solution
+	 * @param moveToSolution
+	 * @param moveFactor
+	 * @return new position
+	 */
+	public static GnpPosition getCenterSolution(ArrayList<GnpPosition> solutions) {
+		GnpPosition returnValue = new GnpPosition(solutions.get(0)
+				.getNoOfDimensions(), solutions.get(0).getHostRef(), solutions
+				.get(0).getGnpRef());
+		for (int d = 0; d < solutions.size(); d++) {
+			for (int c = 0; c < solutions.get(0).getNoOfDimensions(); c++) {
+				returnValue.setGnpCoordinates(c, returnValue
+						.getGnpCoordinates(c)
+						+ solutions.get(d).getGnpCoordinates(c));
+			}
+		}
+		for (int c = 0; c < returnValue.getNoOfDimensions(); c++) {
+			returnValue.setGnpCoordinates(c, returnValue.getGnpCoordinates(c)
+					/ solutions.size());
+		}
+		return returnValue;
 	}
 
 	public GnpPosition clone() {
@@ -323,7 +310,7 @@ public class GnpPosition implements Position, Comparable<GnpPosition> {
 	
 	@Override
 	public double distanceTo(Location dest) {
-		return getDistance((Position) dest);
+		return getDistance(dest);
 	}
 	
 	@Override
@@ -344,5 +331,5 @@ public class GnpPosition implements Position, Comparable<GnpPosition> {
 	@Override
 	public void set(Location l) {
 		throw new UnsupportedOperationException();
-	}
-}
+	}
+}

src/de/tud/kom/p2psim/impl/network/gnp/topology/HostMap.java

@@ -19,8 +19,8 @@
  */
 
 
-package de.tud.kom.p2psim.impl.network.gnp.topology;
-
+package de.tud.kom.p2psim.impl.network.gnp.topology;
+
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -56,66 +56,66 @@ import de.tud.kom.p2psim.impl.network.modular.db.NetMeasurementDB.PingErRegion;
 import de.tud.kom.p2psim.impl.network.modular.db.NetMeasurementDB.Region;
 import de.tudarmstadt.maki.simonstrator.api.Monitor;
 import de.tudarmstadt.maki.simonstrator.api.Monitor.Level;
-
-/**
- * This class holds all informations needed to built an xml-Host File for the
- * simulations with the GnpNetLayer and GnpLatencyModel
- * 
- * @author Gerald Klunker
- * @version 0.1, 05.02.2008
- * 
- */
-public class HostMap {
-
-	private static final String GROUP_WORLD = "World";
-
-	private static final String COUNTRY_UNLOCATABLE = "#UNLOCATABLE_COUNTRY";
-
-	private static final String REGION_UNLOCATABLE = "#UNLOCATABLE_REGION";
-
-	private static final String PINGER_REGION_UNLOCATABLE = "#PINGER_REGION_UNLOCATABLE";
-
-	// importet Files
-	private HashMap<String, HashSet<Host>> skitterFiles = new HashMap<String, HashSet<Host>>();
-
-	private File geolocationFile;
-
-	private IspLookupService ispService;
-
-	// Host Index and Groups
-	private HashMap<Integer, Host> monitorIndex = new HashMap<Integer, Host>();
-
-	private HashMap<Integer, Host> hostIndex = new HashMap<Integer, Host>();
-
-	private ArrayList<Host>[][][] quickLookup;
-
-	private HashMap<String, Set<Host>> groups = new HashMap<String, Set<Host>>();
-
-	// Country - Region - PingEr dictionary
-	private PingErLookup pingErLookup = new PingErLookup();
-
-	private CountryLookup countryLookup = new CountryLookup();
-
-	private GnpSpace gnpRef;
-
-	/**
-	 * import Hosts and RTTs from a CAIDA skitter File
-	 * 
-	 * @param skitterFile
-	 */
-	public void importSkitterFile(File skitterFile, boolean oldFormat) {
-		try {
-
-			skitterFiles.put(skitterFile.getAbsolutePath(), new HashSet<Host>());
-			FileReader inputFile = new FileReader(skitterFile);
-			BufferedReader input = new BufferedReader(inputFile);
-
-			int validLines = 0;
-	
-			String line = input.readLine();
-			while (line != null) {
-				
-				if (line.length() < 1024) {
+
+/**
+ * This class holds all informations needed to built an xml-Host File for the
+ * simulations with the GnpNetLayer and GnpLatencyModel
+ * 
+ * @author Gerald Klunker
+ * @version 0.1, 05.02.2008
+ * 
+ */
+public class HostMap {
+
+	private static final String GROUP_WORLD = "World";
+
+	private static final String COUNTRY_UNLOCATABLE = "#UNLOCATABLE_COUNTRY";
+
+	private static final String REGION_UNLOCATABLE = "#UNLOCATABLE_REGION";
+
+	private static final String PINGER_REGION_UNLOCATABLE = "#PINGER_REGION_UNLOCATABLE";
+
+	// importet Files
+	private HashMap<String, HashSet<Host>> skitterFiles = new HashMap<String, HashSet<Host>>();
+
+	private File geolocationFile;
+
+	private IspLookupService ispService;
+
+	// Host Index and Groups
+	private HashMap<Integer, Host> monitorIndex = new HashMap<Integer, Host>();
+
+	private HashMap<Integer, Host> hostIndex = new HashMap<Integer, Host>();
+
+	private ArrayList<Host>[][][] quickLookup;
+
+	private HashMap<String, Set<Host>> groups = new HashMap<String, Set<Host>>();
+
+	// Country - Region - PingEr dictionary
+	private PingErLookup pingErLookup = new PingErLookup();
+
+	private CountryLookup countryLookup = new CountryLookup();
+
+	private GnpSpace gnpRef;
+
+	/**
+	 * import Hosts and RTTs from a CAIDA skitter File
+	 * 
+	 * @param skitterFile
+	 */
+	public void importSkitterFile(File skitterFile, boolean oldFormat) {
+		try {
+
+			skitterFiles.put(skitterFile.getAbsolutePath(), new HashSet<Host>());
+			FileReader inputFile = new FileReader(skitterFile);
+			BufferedReader input = new BufferedReader(inputFile);
+
+			int validLines = 0;
+	
+			String line = input.readLine();
+			while (line != null) {
+				
+				if (line.length() < 1024) {
 				
 					int commentbegin = line.indexOf("#");
 					String line2parse = commentbegin < 0?line:line.substring(0, commentbegin); //ignore comments
@@ -124,25 +124,25 @@ public class HostMap {
 					if (!"".equals(line2parse.trim())) {
 						if(oldFormat?parseLineOldFormat(line2parse, skitterFile):parseLineNewFormat(line2parse, skitterFile)) validLines++;
 					}
-					
-				} else {
-					//sometimes weird long lines occur when the file is corrupted:
+					
+				} else {
+					//sometimes weird long lines occur when the file is corrupted:
 					Monitor.log(HostMap.class, Level.ERROR,
 							"The weird long line with length " + line.length()
 									+ "' could not be parsed in skitter file "
-									+ skitterFile);
-				}
-				line = input.readLine();
-			}
+									+ skitterFile);
+				}
+				line = input.readLine();
+			}
 			System.gc();
-			System.out.println("Imported " + validLines + " valid entries from skitter file " + skitterFile + ".");
-		} catch (FileNotFoundException e) {
-			e.printStackTrace();
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
-
+			System.out.println("Imported " + validLines + " valid entries from skitter file " + skitterFile + ".");
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
 	private boolean parseLineOldFormat(String line, File skitterFile) {
 		
 		int monitorIP;
@@ -241,889 +241,889 @@ public class HostMap {
 		return false;
 	}
 
-	/**
-	 * import PingER summary report File
-	 * 
-	 * @param file
-	 */
-	public void importPingErMinimumRtt(File file) {
-		pingErLookup.loadFromTSV(file, PingErLookup.DataType.MIN_RTT);
-	}
-
-	/**
-	 * import PingER summary report File
-	 * 
-	 * @param file
-	 */
-	public void importPingErAverageRtt(File file) {
-		pingErLookup.loadFromTSV(file, PingErLookup.DataType.AVERAGE_RTT);
-	}
-
-	/**
-	 * import PingER summary report File
-	 * 
-	 * @param file
-	 */
-	public void importPingErDelayVariation(File file) {
-		pingErLookup.loadFromTSV(file, PingErLookup.DataType.VARIATION_RTT);
-	}
-
-	/**
-	 * import PingER summary report File
-	 * 
-	 * @param file
-	 */
-	public void importPingErPacketLoss(File file) {
-		pingErLookup.loadFromTSV(file, PingErLookup.DataType.PACKET_LOSS);
-	}
-
-	/**
-	 * 
-	 * @return country dictionary
-	 */
-	public CountryLookup getCountryLookup() {
-		return countryLookup;
-	}
-
-	/**
-	 * 
-	 * @return pingerEr lookup table
-	 */
-	public PingErLookup getPingErLookup() {
-		return pingErLookup;
-	}
-
-	/**
-	 * 
-	 * @param longitude
-	 * @param latitude
-	 * @return set of the nearest hosts to longitude/latitude position
-	 */
-	public Set<Host> getNearestHosts(double longitude, double latitude) {
-		HashSet<Host> result = new HashSet<Host>();
-		int index0 = (int) Math.floor(HostMap.getGeographicalDistance(90, 0, latitude, longitude) / 1000.0);
-		int index1 = (int) Math.floor(HostMap.getGeographicalDistance(0, 0, latitude, longitude) / 1000.0);
-		int index2 = (int) Math.floor(HostMap.getGeographicalDistance(0, 90, latitude, longitude) / 1000.0);
-		PeerComparatorDistance comparator = new PeerComparatorDistance();
-		comparator.setPosition(latitude, longitude);
-		Host peer = null;
-		if (quickLookup != null && quickLookup[index0][index1][index2] != null) {
-			for (Host p : quickLookup[index0][index1][index2]) {
-				if (peer == null) {
-					peer = p;
-				} else if (comparator.compare(peer, p) == 1) {
-					peer = p;
-				}
-			}
-			for (Host p : quickLookup[index0][index1][index2]) {
-				if (comparator.compare(peer, p) == 0)
-					result.add(p);
-			}
-		}
-		return result;
-	}
-
-	/**
-	 * rebuilt an array of hosts for fast finding of nearest hosts
-	 */
-	private void builtQuickLookup() {
-		quickLookup = new ArrayList[21][21][21];
-		int index0 = 0;
-		int index1 = 0;
-		int index2 = 0;
-		Set<Integer> ips = this.hostIndex.keySet();
-		for (Integer ip : ips) {
-			index0 = (int) Math.floor(HostMap.getGeographicalDistance(90, 0, hostIndex.get(ip).getLatitude(), hostIndex.get(ip).getLongitude()) / 1000.0);
-			index1 = (int) Math.floor(HostMap.getGeographicalDistance(0, 0, hostIndex.get(ip).getLatitude(), hostIndex.get(ip).getLongitude()) / 1000.0);
-			index2 = (int) Math.floor(HostMap.getGeographicalDistance(0, 90, hostIndex.get(ip).getLatitude(), hostIndex.get(ip).getLongitude()) / 1000.0);
-			if (quickLookup[index0][index1][index2] == null)
-				quickLookup[index0][index1][index2] = new ArrayList<Host>();
-			quickLookup[index0][index1][index2].add(hostIndex.get(ip));
-		}
-	}
-
-	/**
-	 * 
-	 * @return reference to the related GNP Space object
-	 */
-	public GnpSpace getGnpRef() {
-		return gnpRef;
-	}
-
-	/**
-	 * 
-	 * @param gnp
-	 *            reference to the related GNP Space object
-	 */
-	public void setGnpRef(GnpSpace gnp) {
-		gnpRef = gnp;
-	}
-
-	/**
-	 * 
-	 * @return map of importet skitter files and hosts
-	 */
-	public HashMap<String, HashSet<Host>> getImportedSkitterFiles() {
-		return skitterFiles;
-	}
-
-	/**
-	 * counts the number of hosts with a certain number of measured RTTs [0]:
-	 * number of Hosts with 0 measured RTTs, [1] number of Hosts with 1 measured
-	 * RTTs ...
-	 * 
-	 * @return map from number of measured RTTs to number of related hosts
-	 */
-	public int[] getConnectivityOfHosts() {
-		int[] counter = new int[getNoOfMonitors() + 1];
-		for (Host host : hostIndex.values()) {
-			if (host.getHostType() == Host.HOST)
-				counter[host.getMeasuredMonitors().size()]++;
-		}
-		return counter;
-	}
-
-	/**
-	 * 
-	 * @param groupName
-	 * @return Set of Host related to the Group
-	 */
-	public Collection<Host> getGroup(String groupName) {
-		if (groups.containsKey(groupName))
-			return groups.get(groupName);
-		else
-			return new HashSet<Host>();
-	}
-
-	/**
-	 * 
-	 * @return map of groupnames to related hosts
-	 */
-	public HashMap<String, Set<Host>> getGroups() {
-		return groups;
-	}
-
-	/**
-	 * 
-	 * @param groupName
-	 * @param host
-	 */
-	public void addHostToGroup(String groupName, Host host) {
-		String name = groupName.replace(" ", "");
-		if (!groups.containsKey(name))
-			groups.put(name, new HashSet<Host>());
-		groups.get(name).add(host);
-	}
-
-	/**
-	 * 
-	 * @param groupName
-	 * @param hosts
-	 *            set of hosts
-	 */
-	public void addHostToGroup(String groupName, Collection<Host> hosts) {
-		String name = groupName.replace(" ", "");
-		if (!groups.containsKey(name))
-			groups.put(name, new HashSet<Host>());
-		groups.get(name).addAll(hosts);
-	}
-
-	/**
-	 * 
-	 * @param groupName
-	 * @param grid
-	 */
-	public void addHostToGroup(String groupName, boolean grid[][]) {
-		Set<Host>[][] peerGrid = getHostGrid(grid.length, grid[0].length);
-		for (int x = 0; x < grid.length; x++) {
-			for (int y = 0; y < grid[x].length; y++) {
-				if (grid[x][y]) {
-					addHostToGroup(groupName, peerGrid[x][y]);
-				}
-			}
-		}
-	}
-
-	/**
-	 * 
-	 * @param resLon
-	 *            number of horizontal divisions
-	 * @param resLat
-	 *            number of vertical divisions
-	 * @return hosts grouped by their geographical position
-	 */
-	private Set<Host>[][] getHostGrid(int resLon, int resLat) {
-		Set<Host>[][] peerGrid = new HashSet[resLon][resLat];
-		int posLon;
-		int posLat;
-		double stepLon = 360 / (double) resLon;
-		double stepLat = 180 / (double) resLat;
-		for (Host host : hostIndex.values()) {
-			posLon = (int) Math.floor((180 + host.getLongitude()) / stepLon);
-			posLat = (int) Math.floor((90 + host.getLatitude()) / stepLat);
-			if (peerGrid[posLon][posLat] == null)
-				peerGrid[posLon][posLat] = new HashSet<Host>();
-			peerGrid[posLon][posLat].add(host);
-		}
-		return peerGrid;
-	}
-
-	/**
-	 * 
-	 * @param groupName
-	 */
-	public void removeGroup(String groupName) {
-		groups.remove(groupName);
-	}
-
-	/**
-	 * 
-	 * @param groupNames
-	 *            set of group names
-	 */
-	public void removeGroup(Set<String> groupNames) {
-		for (String name : groupNames)
-			removeGroup(name);
-	}
-
-	/**
-	 * reduce the number of hosts in a group
-	 * 
-	 * @param groupName
-	 * @param noOfHosts
-	 */
-	public void scaleGroup(String groupName, int newSize) {
-		Set<Host> oldGroup = groups.get(groupName);
-		Set<Host> newGroup = new HashSet<Host>();
-		while (newGroup.size() < newSize && oldGroup.size() > 0) {
-			Host[] hosts = oldGroup.toArray(new Host[0]);
-			for (int c = 0; c < newSize - newGroup.size(); c++) {
-				int random = (int) Math.floor(Math.random() * hosts.length);
-				newGroup.add(hosts[random]);
-				oldGroup.remove(hosts[random]);
-			}
-		}
-		oldGroup.clear();
-		oldGroup.addAll(newGroup);
-	}
-
-	/**
-	 * generate groups with the name of GeoIP country names
-	 */
-	public void builtCountryGroups() {
-		for (Host host : hostIndex.values()) {
-			String country = countryLookup.getGeoIpCountryName(host.getCountryCode());
-			if (country == null)
-				country = COUNTRY_UNLOCATABLE;
-			this.addHostToGroup(country, host);
-		}
-	}
-
-	/**
-	 * generate groups with the name of GeoIP country names
-	 */
-	public void builtRegionGroups() {
-		for (Host host : hostIndex.values()) {
-			String region = host.getRegion();
-			if (region == null)
-				region = REGION_UNLOCATABLE;
-			this.addHostToGroup(region, host);
-		}
-	}
-
-	/**
-	 * generate groups with the name of PingER region names
-	 */
-	public void builtPingerGroups() {
-		for (Host host : hostIndex.values()) {
-			String country = countryLookup.getPingErRegionName(host.getCountryCode());
-			if (country == null)
-				country = PINGER_REGION_UNLOCATABLE;
-			this.addHostToGroup(country, host);
-		}
-	}
-
-	/**
-	 * built a group with all hosts
-	 */
-	public void builtWorldGroups() {
-		this.addHostToGroup(GROUP_WORLD, hostIndex.values());
-	}
-
-	/**
-	 * 
-	 * @return number of hosts in this map
-	 */
-	public int getNoOfHosts() {
-		return hostIndex.size();
-	}
-
-	/**
-	 * 
-	 * @return number of monitors in this map
-	 */
-	public int getNoOfMonitors() {
-		return monitorIndex.size();
-	}
-
-	/**
-	 * 
-	 * @param file
-	 *            filename of a GeoIP binary database
-	 */
-	public void setGeolocationDatabase(File file) {
-		geolocationFile = file;
-	}
-
-	public void setIspLocationDatabase(String db) {
-		ispService = new IspLookupService(db);
-	}
-
-	/**
-	 * 
-	 * @return filename of the current GeoIP database
-	 */
-	public File getGeolocationDatabase() {
-		return geolocationFile;
-	}
-
-	/**
-	 * position all hosts with the current GeoIP database
-	 */
-	public void setLocationOfHosts() {
-		if (geolocationFile == null) {
-			return;
-		}
-		Geolocator locator = new GeolocatorGeoIP(geolocationFile);
-		for (Host host : hostIndex.values()) {
-			host.setLocation(locator, ispService);
-		}
-		builtQuickLookup();
-		// distanceVsRttPlot("test100", null, 100);
-	}
-
-	/**
-	 * 
-	 * @return map from 2-digits country code to the related hosts
-	 */
-	public HashMap<String, HashSet<Host>> getLocations() {
-		HashMap<String, HashSet<Host>> locations = new HashMap<String, HashSet<Host>>();
-		locations.put("# LOCATABLE", new HashSet<Host>());
-		locations.put("# UNLOCATABLE", new HashSet<Host>());
-		for (Host host : hostIndex.values()) {
-			if (host.isLocatable()) {
-				if (!locations.containsKey(host.getCountryCode()))
-					locations.put(host.getCountryCode(), new HashSet<Host>());
-				locations.get(host.getCountryCode()).add(host);
-				locations.get("# LOCATABLE").add(host);
-			} else {
-				locations.get("# UNLOCATABLE").add(host);
-			}
-		}
-		return locations;
-	}
-
-	/**
-	 * 
-	 * @return map from ip to related monitor Host object
-	 */
-	public HashMap<Integer, Host> getMonitorIndex() {
-		return monitorIndex;
-	}
-
-	/**
-	 * 
-	 * @return map from ip to related Host object
-	 */
-	public HashMap<Integer, Host> getHostIndex() {
-		return hostIndex;
-	}
-
-	/**
-	 * make the measured inter-monitor RTTs adjacency matrix symmetrical. => RTT
-	 * A->B = RTT B->A assumtion is needed within the GNP coordinate model.
-	 */
-	public void makeSymmetrical() {
-		for (Host monitorA : monitorIndex.values()) {
-			for (Host monitorB : monitorIndex.values()) {
-				if (monitorA == monitorB) {
-					monitorA.removeRTT(monitorB);
-				} else {
-					double rtt1 = monitorA.getRtt(monitorB);
-					double rtt2 = monitorB.getRtt(monitorA);
-					double newRtt = Double.NaN;
-					if (rtt1 > 0 && rtt2 > 0)
-						newRtt = (rtt1 + rtt2) / 2;
-					else if (rtt1 > 0)
-						newRtt = rtt1;
-					else if (rtt2 > 0)
-						newRtt = rtt2;
-					monitorA.setRtt(monitorB, newRtt);
-					monitorB.setRtt(monitorA, newRtt);
-				}
-			}
-		}
-	}
-
-	/**
-	 * 
-	 * @param p1
-	 *            host 1
-	 * @param p2
-	 *            host 2
-	 * @return distance in km
-	 */
-	private static double getGeographicalDistance(Host p1, Host p2) {
-		return HostMap.getGeographicalDistance(p1.getLatitude(), p1.getLongitude(), p2.getLatitude(), p2.getLongitude());
-	}
-
-	/**
-	 * 
-	 * @param latitude1
-	 *            host 1
-	 * @param longitude1
-	 *            host 1
-	 * @param latitude2
-	 *            host 2
-	 * @param longitude2
-	 *            host 2
-	 * @return distance in km
-	 */
-	private static double getGeographicalDistance(double latitude1, double longitude1, double latitude2, double longitude2) {
-		GeographicPosition pos1 = new GeographicPosition(longitude1, latitude1);
-		GeographicPosition pos2 = new GeographicPosition(longitude2, latitude2);
-		return pos1.getDistance(pos2);
-	}
-
-	/**
-	 * unlocatable on the globe (unkonw ip, proxy, satelite)
-	 * 
-	 * @return number of unlocatable hosts
-	 */
-	public int getNoOfUnlocatableHosts() {
-		int unlocatedPeers = 0;
-		int unlocatedMonitors = 0;
-		Set<Integer> ips = this.hostIndex.keySet();
-		for (Integer ip : ips) {
-			unlocatedPeers += (hostIndex.get(ip).isLocatable()) ? 0 : 1;
-			unlocatedMonitors += (hostIndex.get(ip).isLocatable() || hostIndex.get(ip).getHostType() == Host.HOST) ? 0 : 1;
-		}
-		return unlocatedPeers - unlocatedMonitors;
-	}
-
-	/**
-	 * 
-	 * @param monitor
-	 */
-	public void removeMonitor(Host monitor) {
-		this.monitorIndex.remove(monitor.getIpAddress());
-		this.hostIndex.remove(monitor.getIpAddress());
-		for (Host host : hostIndex.values()) {
-			host.removeRTT(monitor);
-		}
-		this.builtQuickLookup();
-	}
-
-	/**
+	/**
+	 * import PingER summary report File
+	 * 
+	 * @param file
+	 */
+	public void importPingErMinimumRtt(File file) {
+		pingErLookup.loadFromTSV(file, PingErLookup.DataType.MIN_RTT);
+	}
+
+	/**
+	 * import PingER summary report File
+	 * 
+	 * @param file
+	 */
+	public void importPingErAverageRtt(File file) {
+		pingErLookup.loadFromTSV(file, PingErLookup.DataType.AVERAGE_RTT);
+	}
+
+	/**
+	 * import PingER summary report File
+	 * 
+	 * @param file
+	 */
+	public void importPingErDelayVariation(File file) {
+		pingErLookup.loadFromTSV(file, PingErLookup.DataType.VARIATION_RTT);
+	}
+
+	/**
+	 * import PingER summary report File
+	 * 
+	 * @param file
+	 */
+	public void importPingErPacketLoss(File file) {
+		pingErLookup.loadFromTSV(file, PingErLookup.DataType.PACKET_LOSS);
+	}
+
+	/**
+	 * 
+	 * @return country dictionary
+	 */
+	public CountryLookup getCountryLookup() {
+		return countryLookup;
+	}
+
+	/**
+	 * 
+	 * @return pingerEr lookup table
+	 */
+	public PingErLookup getPingErLookup() {
+		return pingErLookup;
+	}
+
+	/**
+	 * 
+	 * @param longitude
+	 * @param latitude
+	 * @return set of the nearest hosts to longitude/latitude position
+	 */
+	public Set<Host> getNearestHosts(double longitude, double latitude) {
+		HashSet<Host> result = new HashSet<Host>();
+		int index0 = (int) Math.floor(HostMap.getGeographicalDistance(90, 0, latitude, longitude) / 1000.0);
+		int index1 = (int) Math.floor(HostMap.getGeographicalDistance(0, 0, latitude, longitude) / 1000.0);
+		int index2 = (int) Math.floor(HostMap.getGeographicalDistance(0, 90, latitude, longitude) / 1000.0);
+		PeerComparatorDistance comparator = new PeerComparatorDistance();
+		comparator.setPosition(latitude, longitude);
+		Host peer = null;
+		if (quickLookup != null && quickLookup[index0][index1][index2] != null) {
+			for (Host p : quickLookup[index0][index1][index2]) {
+				if (peer == null) {
+					peer = p;
+				} else if (comparator.compare(peer, p) == 1) {
+					peer = p;
+				}
+			}
+			for (Host p : quickLookup[index0][index1][index2]) {
+				if (comparator.compare(peer, p) == 0)
+					result.add(p);
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * rebuilt an array of hosts for fast finding of nearest hosts
+	 */
+	private void builtQuickLookup() {
+		quickLookup = new ArrayList[21][21][21];
+		int index0 = 0;
+		int index1 = 0;
+		int index2 = 0;
+		Set<Integer> ips = this.hostIndex.keySet();
+		for (Integer ip : ips) {
+			index0 = (int) Math.floor(HostMap.getGeographicalDistance(90, 0, hostIndex.get(ip).getLatitude(), hostIndex.get(ip).getLongitude()) / 1000.0);
+			index1 = (int) Math.floor(HostMap.getGeographicalDistance(0, 0, hostIndex.get(ip).getLatitude(), hostIndex.get(ip).getLongitude()) / 1000.0);
+			index2 = (int) Math.floor(HostMap.getGeographicalDistance(0, 90, hostIndex.get(ip).getLatitude(), hostIndex.get(ip).getLongitude()) / 1000.0);
+			if (quickLookup[index0][index1][index2] == null)
+				quickLookup[index0][index1][index2] = new ArrayList<Host>();
+			quickLookup[index0][index1][index2].add(hostIndex.get(ip));
+		}
+	}
+
+	/**
+	 * 
+	 * @return reference to the related GNP Space object
+	 */
+	public GnpSpace getGnpRef() {
+		return gnpRef;
+	}
+
+	/**
+	 * 
+	 * @param gnp
+	 *            reference to the related GNP Space object
+	 */
+	public void setGnpRef(GnpSpace gnp) {
+		gnpRef = gnp;
+	}
+
+	/**
+	 * 
+	 * @return map of importet skitter files and hosts
+	 */
+	public HashMap<String, HashSet<Host>> getImportedSkitterFiles() {
+		return skitterFiles;
+	}
+
+	/**
+	 * counts the number of hosts with a certain number of measured RTTs [0]:
+	 * number of Hosts with 0 measured RTTs, [1] number of Hosts with 1 measured
+	 * RTTs ...
+	 * 
+	 * @return map from number of measured RTTs to number of related hosts
+	 */
+	public int[] getConnectivityOfHosts() {
+		int[] counter = new int[getNoOfMonitors() + 1];
+		for (Host host : hostIndex.values()) {
+			if (host.getHostType() == Host.HOST)
+				counter[host.getMeasuredMonitors().size()]++;
+		}
+		return counter;
+	}
+
+	/**
+	 * 
+	 * @param groupName
+	 * @return Set of Host related to the Group
+	 */
+	public Collection<Host> getGroup(String groupName) {
+		if (groups.containsKey(groupName))
+			return groups.get(groupName);
+		else
+			return new HashSet<Host>();
+	}
+
+	/**
+	 * 
+	 * @return map of groupnames to related hosts
+	 */
+	public HashMap<String, Set<Host>> getGroups() {
+		return groups;
+	}
+
+	/**
+	 * 
+	 * @param groupName
+	 * @param host
+	 */
+	public void addHostToGroup(String groupName, Host host) {
+		String name = groupName.replace(" ", "");
+		if (!groups.containsKey(name))
+			groups.put(name, new HashSet<Host>());
+		groups.get(name).add(host);
+	}
+
+	/**
+	 * 
+	 * @param groupName
+	 * @param hosts
+	 *            set of hosts
+	 */
+	public void addHostToGroup(String groupName, Collection<Host> hosts) {
+		String name = groupName.replace(" ", "");
+		if (!groups.containsKey(name))
+			groups.put(name, new HashSet<Host>());
+		groups.get(name).addAll(hosts);
+	}
+
+	/**
+	 * 
+	 * @param groupName
+	 * @param grid
+	 */
+	public void addHostToGroup(String groupName, boolean grid[][]) {
+		Set<Host>[][] peerGrid = getHostGrid(grid.length, grid[0].length);
+		for (int x = 0; x < grid.length; x++) {
+			for (int y = 0; y < grid[x].length; y++) {
+				if (grid[x][y]) {
+					addHostToGroup(groupName, peerGrid[x][y]);
+				}
+			}
+		}
+	}
+
+	/**
+	 * 
+	 * @param resLon
+	 *            number of horizontal divisions
+	 * @param resLat
+	 *            number of vertical divisions
+	 * @return hosts grouped by their geographical position
+	 */
+	private Set<Host>[][] getHostGrid(int resLon, int resLat) {
+		Set<Host>[][] peerGrid = new HashSet[resLon][resLat];
+		int posLon;
+		int posLat;
+		double stepLon = 360 / (double) resLon;
+		double stepLat = 180 / (double) resLat;
+		for (Host host : hostIndex.values()) {
+			posLon = (int) Math.floor((180 + host.getLongitude()) / stepLon);
+			posLat = (int) Math.floor((90 + host.getLatitude()) / stepLat);
+			if (peerGrid[posLon][posLat] == null)
+				peerGrid[posLon][posLat] = new HashSet<Host>();
+			peerGrid[posLon][posLat].add(host);
+		}
+		return peerGrid;
+	}
+
+	/**
+	 * 
+	 * @param groupName
+	 */
+	public void removeGroup(String groupName) {
+		groups.remove(groupName);
+	}
+
+	/**
+	 * 
+	 * @param groupNames
+	 *            set of group names
+	 */
+	public void removeGroup(Set<String> groupNames) {
+		for (String name : groupNames)
+			removeGroup(name);
+	}
+
+	/**
+	 * reduce the number of hosts in a group
+	 * 
+	 * @param groupName
+	 * @param noOfHosts
+	 */
+	public void scaleGroup(String groupName, int newSize) {
+		Set<Host> oldGroup = groups.get(groupName);
+		Set<Host> newGroup = new HashSet<Host>();
+		while (newGroup.size() < newSize && oldGroup.size() > 0) {
+			Host[] hosts = oldGroup.toArray(new Host[0]);
+			for (int c = 0; c < newSize - newGroup.size(); c++) {
+				int random = (int) Math.floor(Math.random() * hosts.length);
+				newGroup.add(hosts[random]);
+				oldGroup.remove(hosts[random]);
+			}
+		}
+		oldGroup.clear();
+		oldGroup.addAll(newGroup);
+	}
+
+	/**
+	 * generate groups with the name of GeoIP country names
+	 */
+	public void builtCountryGroups() {
+		for (Host host : hostIndex.values()) {
+			String country = countryLookup.getGeoIpCountryName(host.getCountryCode());
+			if (country == null)
+				country = COUNTRY_UNLOCATABLE;
+			this.addHostToGroup(country, host);
+		}
+	}
+
+	/**
+	 * generate groups with the name of GeoIP country names
+	 */
+	public void builtRegionGroups() {
+		for (Host host : hostIndex.values()) {
+			String region = host.getRegion();
+			if (region == null)
+				region = REGION_UNLOCATABLE;
+			this.addHostToGroup(region, host);
+		}
+	}
+
+	/**
+	 * generate groups with the name of PingER region names
+	 */
+	public void builtPingerGroups() {
+		for (Host host : hostIndex.values()) {
+			String country = countryLookup.getPingErRegionName(host.getCountryCode());
+			if (country == null)
+				country = PINGER_REGION_UNLOCATABLE;
+			this.addHostToGroup(country, host);
+		}
+	}
+
+	/**
+	 * built a group with all hosts
+	 */
+	public void builtWorldGroups() {
+		this.addHostToGroup(GROUP_WORLD, hostIndex.values());
+	}
+
+	/**
+	 * 
+	 * @return number of hosts in this map
+	 */
+	public int getNoOfHosts() {
+		return hostIndex.size();
+	}
+
+	/**
+	 * 
+	 * @return number of monitors in this map
+	 */
+	public int getNoOfMonitors() {
+		return monitorIndex.size();
+	}
+
+	/**
+	 * 
+	 * @param file
+	 *            filename of a GeoIP binary database
+	 */
+	public void setGeolocationDatabase(File file) {
+		geolocationFile = file;
+	}
+
+	public void setIspLocationDatabase(String db) {
+		ispService = new IspLookupService(db);
+	}
+
+	/**
+	 * 
+	 * @return filename of the current GeoIP database
+	 */
+	public File getGeolocationDatabase() {
+		return geolocationFile;
+	}
+
+	/**
+	 * position all hosts with the current GeoIP database
+	 */
+	public void setLocationOfHosts() {
+		if (geolocationFile == null) {
+			return;
+		}
+		Geolocator locator = new GeolocatorGeoIP(geolocationFile);
+		for (Host host : hostIndex.values()) {
+			host.setLocation(locator, ispService);
+		}
+		builtQuickLookup();
+		// distanceVsRttPlot("test100", null, 100);
+	}
+
+	/**
+	 * 
+	 * @return map from 2-digits country code to the related hosts
+	 */
+	public HashMap<String, HashSet<Host>> getLocations() {
+		HashMap<String, HashSet<Host>> locations = new HashMap<String, HashSet<Host>>();
+		locations.put("# LOCATABLE", new HashSet<Host>());
+		locations.put("# UNLOCATABLE", new HashSet<Host>());
+		for (Host host : hostIndex.values()) {
+			if (host.isLocatable()) {
+				if (!locations.containsKey(host.getCountryCode()))
+					locations.put(host.getCountryCode(), new HashSet<Host>());
+				locations.get(host.getCountryCode()).add(host);
+				locations.get("# LOCATABLE").add(host);
+			} else {
+				locations.get("# UNLOCATABLE").add(host);
+			}
+		}
+		return locations;
+	}
+
+	/**
+	 * 
+	 * @return map from ip to related monitor Host object
+	 */
+	public HashMap<Integer, Host> getMonitorIndex() {
+		return monitorIndex;
+	}
+
+	/**
+	 * 
+	 * @return map from ip to related Host object
+	 */
+	public HashMap<Integer, Host> getHostIndex() {
+		return hostIndex;
+	}
+
+	/**
+	 * make the measured inter-monitor RTTs adjacency matrix symmetrical. => RTT
+	 * A->B = RTT B->A assumtion is needed within the GNP coordinate model.
+	 */
+	public void makeSymmetrical() {
+		for (Host monitorA : monitorIndex.values()) {
+			for (Host monitorB : monitorIndex.values()) {
+				if (monitorA == monitorB) {
+					monitorA.removeRTT(monitorB);
+				} else {
+					double rtt1 = monitorA.getRtt(monitorB);
+					double rtt2 = monitorB.getRtt(monitorA);
+					double newRtt = Double.NaN;
+					if (rtt1 > 0 && rtt2 > 0)
+						newRtt = (rtt1 + rtt2) / 2;
+					else if (rtt1 > 0)
+						newRtt = rtt1;
+					else if (rtt2 > 0)
+						newRtt = rtt2;
+					monitorA.setRtt(monitorB, newRtt);
+					monitorB.setRtt(monitorA, newRtt);
+				}
+			}
+		}
+	}
+
+	/**
+	 * 
+	 * @param p1
+	 *            host 1
+	 * @param p2
+	 *            host 2
+	 * @return distance in km
+	 */
+	private static double getGeographicalDistance(Host p1, Host p2) {
+		return HostMap.getGeographicalDistance(p1.getLatitude(), p1.getLongitude(), p2.getLatitude(), p2.getLongitude());
+	}
+
+	/**
+	 * 
+	 * @param latitude1
+	 *            host 1
+	 * @param longitude1
+	 *            host 1
+	 * @param latitude2
+	 *            host 2
+	 * @param longitude2
+	 *            host 2
+	 * @return distance in km
+	 */
+	private static double getGeographicalDistance(double latitude1, double longitude1, double latitude2, double longitude2) {
+		GeographicPosition pos1 = new GeographicPosition(longitude1, latitude1);
+		GeographicPosition pos2 = new GeographicPosition(longitude2, latitude2);
+		return pos1.distanceTo(pos2);
+	}
+
+	/**
+	 * unlocatable on the globe (unkonw ip, proxy, satelite)
+	 * 
+	 * @return number of unlocatable hosts
+	 */
+	public int getNoOfUnlocatableHosts() {
+		int unlocatedPeers = 0;
+		int unlocatedMonitors = 0;
+		Set<Integer> ips = this.hostIndex.keySet();
+		for (Integer ip : ips) {
+			unlocatedPeers += (hostIndex.get(ip).isLocatable()) ? 0 : 1;
+			unlocatedMonitors += (hostIndex.get(ip).isLocatable() || hostIndex.get(ip).getHostType() == Host.HOST) ? 0 : 1;
+		}
+		return unlocatedPeers - unlocatedMonitors;
+	}
+
+	/**
+	 * 
+	 * @param monitor
+	 */
+	public void removeMonitor(Host monitor) {
+		this.monitorIndex.remove(monitor.getIpAddress());
+		this.hostIndex.remove(monitor.getIpAddress());
+		for (Host host : hostIndex.values()) {
+			host.removeRTT(monitor);
+		}
+		this.builtQuickLookup();
+	}
+
+	/**
 	 * 
 	 * Removes the given set of hosts from the map.
-	 * 
-	 * @param hosts
-	 *            set of hosts
-	 */
-	public void removeHosts(Set<Host> hosts) {
-		for (Host host : hosts) {
-			// if (host.getHostType() == Host.HOST) {
-			if (this.getGnpRef() != null)
-				this.getGnpRef().removePosition(host.getIpAddress());
-			this.hostIndex.remove(host.getIpAddress());
-			// }
-		}
-		for (Set<Host> group : groups.values())
-			group.removeAll(hosts);
-		countryLookup.keepCountries(getLocations().keySet());
-		this.builtQuickLookup();
-	}
-
+	 * 
+	 * @param hosts
+	 *            set of hosts
+	 */
+	public void removeHosts(Set<Host> hosts) {
+		for (Host host : hosts) {
+			// if (host.getHostType() == Host.HOST) {
+			if (this.getGnpRef() != null)
+				this.getGnpRef().removePosition(host.getIpAddress());
+			this.hostIndex.remove(host.getIpAddress());
+			// }
+		}
+		for (Set<Host> group : groups.values())
+			group.removeAll(hosts);
+		countryLookup.keepCountries(getLocations().keySet());
+		this.builtQuickLookup();
+	}
+
 	/**
 	 * SEEMS TO remove all hosts that were pinged by exactly noOfConnections
 	 * distinct monitors.
-	 * 
-	 * removes all hosts that have noOfConnections measured RTTs
-	 * 
-	 * @param noOfConnections
-	 */
-	public void removeHosts(int noOfConnections) {
-		Set<Host> hosts = new HashSet<Host>();
-		for (Host host : hostIndex.values()) {
-			if (host.getMeasuredMonitors().size() == noOfConnections)
-				hosts.add(host);
-		}
-		removeHosts(hosts);
-	}
-
-	/**
-	 * remove all hosts that have at least one measured RTT with a error bigger
-	 * than the argument. Removing that errors will improve the quality of the
-	 * Gnp Space.
-	 * 
-	 * @param error
-	 *            relative error
-	 */
-	public void removeHostsWithMaximumRelativeError(double error) {
-		HashSet<Host> delete = new HashSet<Host>();
-		for (Host host : hostIndex.values()) {
-			for (int c = 0; c < gnpRef.getNumberOfMonitors(); c++) {
-				double relError = Math.abs(host.getGnpPositionReference().getDirectionalRelativError(gnpRef.getMonitorPosition(c)));
-				if (relError >= error) {
-					delete.add(host);
-					break;
-				}
-			}
-		}
-		removeHosts(delete);
-	}
-
+	 * 
+	 * removes all hosts that have noOfConnections measured RTTs
+	 * 
+	 * @param noOfConnections
+	 */
+	public void removeHosts(int noOfConnections) {
+		Set<Host> hosts = new HashSet<Host>();
+		for (Host host : hostIndex.values()) {
+			if (host.getMeasuredMonitors().size() == noOfConnections)
+				hosts.add(host);
+		}
+		removeHosts(hosts);
+	}
+
+	/**
+	 * remove all hosts that have at least one measured RTT with a error bigger
+	 * than the argument. Removing that errors will improve the quality of the
+	 * Gnp Space.
+	 * 
+	 * @param error
+	 *            relative error
+	 */
+	public void removeHostsWithMaximumRelativeError(double error) {
+		HashSet<Host> delete = new HashSet<Host>();
+		for (Host host : hostIndex.values()) {
+			for (int c = 0; c < gnpRef.getNumberOfMonitors(); c++) {
+				double relError = Math.abs(host.getGnpPositionReference().getDirectionalRelativError(gnpRef.getMonitorPosition(c)));
+				if (relError >= error) {
+					delete.add(host);
+					break;
+				}
+			}
+		}
+		removeHosts(delete);
+	}
+
 	/**
 	 * SEEMS TO only keep the 'noOfMonitorsToKeep' monitor hosts in the GNP space that have the 
 	 * maximum distance between each other, the other ones are being deleted.
-	 * 
-	 * keeps the maximum separated monitors
-	 * 
-	 * @param noOfMonitorsToKeep
-	 */
-	public void removeMonitorsKeepMaximumSparation(int noOfMonitorsToKeep) {
-		ArrayList<Host> maxSeperatedPeers = getMaximumSeparatedMonitors(noOfMonitorsToKeep);
-		ArrayList<Host> deleteMonitors = new ArrayList<Host>();
-		for (Host monitor : monitorIndex.values()) {
-			if (!maxSeperatedPeers.contains(monitor))
-				deleteMonitors.add(monitor);
-		}
-		for (Host monitor : deleteMonitors) {
-			this.removeMonitor(monitor);
-		}
-	}
-
-	/**
 	 * 
-	 * 
-	 * @param noOfMonitors
-	 * @return maximum separated monitors
-	 */
-	private ArrayList<Host> getMaximumSeparatedMonitors(int noOfMonitors) {
-		ArrayList<ArrayList<Host>> allCombinations = getMonitorCombinations(noOfMonitors);
-		int posWithMax = 0;
-		double valueMax = 0.0;
-		for (int c = 0; c < allCombinations.size(); c++) {
-			double currentDistance = getInterMonitorDistance(allCombinations.get(c));
-			if (currentDistance > valueMax) {
-				valueMax = currentDistance;
-				posWithMax = c;
-			}
-		}
-		return allCombinations.get(posWithMax);
-	}
-
-	/**
-	 * 
-	 * @param monitors
-	 * @return sum measured RTTs between monitors
-	 */
-	private double getInterMonitorDistance(ArrayList<Host> monitors) {
-		double result = 0.0;
-		for (int c = 0; c < monitors.size() - 1; c++)
-			for (int d = c + 1; d < monitors.size(); d++)
-				result += monitors.get(c).getRtt(monitors.get(d));
-		return result;
-
-	}
-
-	/**
-	 * 
-	 * @param size
-	 * @return all combinations of monitors with size "size"
-	 */
-	private ArrayList<ArrayList<Host>> getMonitorCombinations(int size) {
-		ArrayList<Host> monitors = new ArrayList<Host>();
-		monitors.addAll(monitorIndex.values());
-		Collections.sort(monitors, new PeerComparatorNoOfConnections());
-		return builtRecursive(new ArrayList<Host>(), size, monitors, 0);
-	}
-
-	/**
-	 * recursive built of all combinations of monitors with size "size"
-	 * 
-	 * @param current
-	 * @param max
-	 * @param monitors
-	 * @param posInMonitors
-	 * @return array of combinations
-	 */
-	private ArrayList<ArrayList<Host>> builtRecursive(ArrayList<Host> current, int max, ArrayList<Host> monitors, int posInMonitors) {
-		ArrayList<ArrayList<Host>> result = new ArrayList<ArrayList<Host>>();
-		if (current.size() == max) {
-			result.add(current);
-			return result;
-		} else {
-			for (int c = posInMonitors; c < monitors.size() - (max - current.size()); c++) {
-				ArrayList<Host> copy = (ArrayList<Host>) current.clone();
-				copy.add(monitors.get(c));
-				result.addAll(builtRecursive(copy, max, monitors, c + 1));
-			}
-			return result;
-		}
-	}
-
-	/**
-	 * generate two files with distance - rtt pairs, that can be used with
-	 * gnuplot
-	 * 
-	 * filename.txt1 plots each measured host - monitor RTT filename.txt2
-	 * aggregates distances within a range and calculates the average RTT
-	 * 
-	 * @param filename
-	 * @param steps
-	 *            number of divisions within the 0 - 20000km for aggregated plot
-	 */
-	public void distanceVsRttPlot(String filename, Host monitor, int steps) {
-		try {
-			double[] test1 = new double[steps];
-			int[] test2 = new int[steps];
-
-			FileWriter all = new FileWriter(filename + ".txt1");
-			for (Host host : hostIndex.values()) {
-				for (Host mon : host.getMeasuredMonitors()) {
-					double distance = getGeographicalDistance(host, mon);
-					double rtt = host.getRtt(mon);
-					all.write(distance + " " + rtt + "\n");
-
-					int pos = (int) Math.floor((distance / 20000.0) * steps);
-					test1[pos] += rtt;
-					test2[pos]++;
-				}
-			}
-			all.close();
-			all = new FileWriter(filename + ".txt2");
-			for (int c = 0; c < steps; c++) {
-				double x = (c * (20000.0 / steps)) + (20000.0 / (2 * steps));
-				double y = test1[c] / test2[c];
-				all.write(x + " " + y + "\n");
-			}
-			all.close();
-
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
-
-	/**
-	 * saves host postion location, GNP position, groups, GNP Space, PingER
-	 * Lookup table in an xml file used within the simulation
-	 * 
-	 * @param file
-	 */
-	public void exportToXml(File file) {
-		try {
-			OutputFormat format = OutputFormat.createPrettyPrint();
-			OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
-			XMLWriter writer = new XMLWriter(out, format);
-			writer.write(getDocument());
-			writer.close();
-		} catch (IOException e) {
-			System.out.println(e);
-		}
-	}
-
-	/**
-	 * 
-	 * @return xml Document Object of relevant Class Attributes
-	 */
-	private Document getDocument() {
-		Set<Host> hosts = new HashSet<Host>();
-
-		// "GroupLookup" Element
-		DefaultElement groups = new DefaultElement("GroupLookup");
-		for (String group : this.groups.keySet()) {
-			hosts.addAll(this.groups.get(group));
-			DefaultElement peerXml = new DefaultElement("Group");
-			peerXml.addAttribute("id", group);
-			peerXml.addAttribute("maxsize", String.valueOf(this.groups.get(group).size()));
-			String ip = "";
-			int x = 0;
-			int blockSize = 1000;
-			// IP Block of 1000, too long blocks leads to hangUp ??
-			for (Host host : this.groups.get(group)) {
-				x++;
-				ip += "," + host.getIpAddress();
-				if (x % blockSize == 0) {
-					ip = ip.substring(1);
-					DefaultElement ips = new DefaultElement("IPs");
-					ips.addAttribute("value", ip);
-					peerXml.add(ips);
-					ip = "";
-				}
-			}
-			if (ip.length() > 0) {
-				ip = ip.substring(1);
-				DefaultElement ips = new DefaultElement("IPs");
-				ips.addAttribute("value", ip);
-				peerXml.add(ips);
-			}
-			groups.add(peerXml);
-		}
-
-		// "Hosts" Element
-		DefaultElement peers = new DefaultElement("Hosts");
-		for (Host host : hosts) {
-			DefaultElement peer = new DefaultElement("Host");
-			peer.addAttribute("ip", String.valueOf(host.getIpAddress()));
-
-			String area = (host.getArea() != null) ? host.getArea() : "--";
-			peer.addAttribute("continentalArea", area);
-
-			String countryCode = (host.getCountryCode() != null) ? host.getCountryCode() : "--";
-			peer.addAttribute("countryCode", countryCode);
-
-			String region = (host.getRegion() != null) ? host.getRegion() : "--";
-			peer.addAttribute("region", region);
-
-			String city = (host.getCity() != null) ? host.getCity() : "--";
-			peer.addAttribute("city", city);
-
-			String isp = (host.getISP() != null) ? host.getISP() : "--";
-			peer.addAttribute("isp", isp);
-
-			peer.addAttribute("longitude", String.valueOf(host.getLongitude()));
-			peer.addAttribute("latitude", String.valueOf(host.getLatitude()));
-			String coordinates = (host.getGnpPositionReference() != null) ? host.getGnpPositionReference().getCoordinateString() : "0";
-			peer.addAttribute("coordinates", coordinates);
-			peers.add(peer);
-		}
-
-		// "PingErLookup" Elements
-		Element pingEr = pingErLookup.exportToXML();
-
-		// "CountryLookup" Element
-		Element country = countryLookup.exportToXML();
-
-		DefaultDocument document = new DefaultDocument(new DefaultElement("gnp"));
-		document.getRootElement().add(groups);
-		document.getRootElement().add(peers);
-		document.getRootElement().add(pingEr);
-		document.getRootElement().add(country);
-		return document;
-
-	}
-	
-	public void insertIntoRelationalDB(NetMeasurementDB db) {
-		
-		Map<Host, NetMeasurementDB.Host> hostsScanned = new HashMap<Host, NetMeasurementDB.Host>();
-		
-		for (String group : this.groups.keySet()) {
-			
-			Set<Host> hosts = this.groups.get(group);
-			
-			List<NetMeasurementDB.Host> dbHosts = new ArrayList<NetMeasurementDB.Host>(hosts.size());
-			
-			for (Host h : hosts) {
-				
-				NetMeasurementDB.Host host = hostsScanned.get(h);
-				
-				if (host == null) {
-					
-					String countryStr = h.getCountryName();
-					String pingErRegionStr = countryLookup.getPingErRegionName(countryStr);
-					assert pingErRegionStr != null : "No PingEr region found for country " + countryStr;
-					City city = getCity(db, h.getCity(), h.getRegion(), countryStr, h.getCountryCode(), h.getArea(), pingErRegionStr);
-					
-					GnpPosition pos = h.getGnpPositionReference();
-					List<Double> gnpCoords;
-					if (pos != null) {
-						int dims = pos.getNoOfDimensions();
-						gnpCoords = new ArrayList<Double>(dims);
-						for (int i= 0; i<dims; i++) gnpCoords.add(pos.getGnpCoordinates(i));
-					} else {
-						gnpCoords = Collections.emptyList();
-					}
-					host = db.new Host(h.getIpAddress(), city, h.getLatitude(), h.getLongitude(), gnpCoords);
-					hostsScanned.put(h, host);
-				}
-			
-				dbHosts.add(host);
-				
-			}
-			
-			db.new Group(group, dbHosts);
-			
-		}
-
-		pingErLookup.insertIntoRelationalDB(db);
-	}
-	
-	public static City getCity(NetMeasurementDB db, String cityStr, String regionStr, String countryStr, String countryCode, String continentStr, String pingErRgName) {
-		//the host never occured in a group before. Putting it into the DB.
-		//FIXME: some cities or regions occur multiple times but in different regions/countries, we will have to separate them! Infers problem of DB structure.
-		City city = db.getStringAddrObjFromStr(City.class, cityStr);
-		if (city == null) {
-			Region region = db.getStringAddrObjFromStr(Region.class, regionStr);
-			if (region == null) {
-				Country country = db.getStringAddrObjFromStr(Country.class, countryStr);
-				if (country == null) {
-					Continent continent = db.getStringAddrObjFromStr(Continent.class, continentStr);
-					if (continent == null) continent = db.new Continent(continentStr);
-					
-					PingErRegion pErRegion = db.getStringAddrObjFromStr(PingErRegion.class, pingErRgName);
-					if (pErRegion == null) pErRegion = db.new PingErRegion(pingErRgName);
-					country = db.new Country(countryStr, continent, pErRegion, countryCode);
-				}
-				region = db.new Region(regionStr, country);
-			}
-			city = db.new City(cityStr, region);
-		}
-		return city;
-	}
-
-	/**
-	 * Comparator implementation for sorting of Host with the geographical
-	 * distance to a given position
-	 */
-	private class PeerComparatorDistance implements Comparator<Host> {
-
-		double latitude;
-
-		double longitude;
-
-		public void setPosition(double latitude, double longitude) {
-			this.latitude = latitude;
-			this.longitude = longitude;
-		}
-
-		public int compare(Host peer1, Host peer2) {
-			double distance1 = HostMap.getGeographicalDistance(peer1.getLatitude(), peer1.getLongitude(), latitude, longitude);
-			double distance2 = HostMap.getGeographicalDistance(peer2.getLatitude(), peer2.getLongitude(), latitude, longitude);
-			if (distance1 < distance2)
-				return -1;
-			else if (distance1 > distance2)
-				return 1;
-			else
-				return 0;
-		}
-	}
-
-	/**
-	 * Comparator implementation for sorting of Host with the number of measured
-	 * RTTs per Host.
-	 */
-	private class PeerComparatorNoOfConnections implements Comparator<Host> {
-		public int compare(Host peer1, Host peer2) {
-			int coonections1 = peer1.getMeasuredMonitors().size();
-			int coonections2 = peer2.getMeasuredMonitors().size();
-			if (coonections1 < coonections2)
-				return 1;
-			else if (coonections1 > coonections2)
-				return -1;
-			else
-				return 0;
-		}
-	}
-}
+	 * keeps the maximum separated monitors
+	 * 
+	 * @param noOfMonitorsToKeep
+	 */
+	public void removeMonitorsKeepMaximumSparation(int noOfMonitorsToKeep) {
+		ArrayList<Host> maxSeperatedPeers = getMaximumSeparatedMonitors(noOfMonitorsToKeep);
+		ArrayList<Host> deleteMonitors = new ArrayList<Host>();
+		for (Host monitor : monitorIndex.values()) {
+			if (!maxSeperatedPeers.contains(monitor))
+				deleteMonitors.add(monitor);
+		}
+		for (Host monitor : deleteMonitors) {
+			this.removeMonitor(monitor);
+		}
+	}
+
+	/**
+	 * 
+	 * 
+	 * @param noOfMonitors
+	 * @return maximum separated monitors
+	 */
+	private ArrayList<Host> getMaximumSeparatedMonitors(int noOfMonitors) {
+		ArrayList<ArrayList<Host>> allCombinations = getMonitorCombinations(noOfMonitors);
+		int posWithMax = 0;
+		double valueMax = 0.0;
+		for (int c = 0; c < allCombinations.size(); c++) {
+			double currentDistance = getInterMonitorDistance(allCombinations.get(c));
+			if (currentDistance > valueMax) {
+				valueMax = currentDistance;
+				posWithMax = c;
+			}
+		}
+		return allCombinations.get(posWithMax);
+	}
+
+	/**
+	 * 
+	 * @param monitors
+	 * @return sum measured RTTs between monitors
+	 */
+	private double getInterMonitorDistance(ArrayList<Host> monitors) {
+		double result = 0.0;
+		for (int c = 0; c < monitors.size() - 1; c++)
+			for (int d = c + 1; d < monitors.size(); d++)
+				result += monitors.get(c).getRtt(monitors.get(d));
+		return result;
+
+	}
+
+	/**
+	 * 
+	 * @param size
+	 * @return all combinations of monitors with size "size"
+	 */
+	private ArrayList<ArrayList<Host>> getMonitorCombinations(int size) {
+		ArrayList<Host> monitors = new ArrayList<Host>();
+		monitors.addAll(monitorIndex.values());
+		Collections.sort(monitors, new PeerComparatorNoOfConnections());
+		return builtRecursive(new ArrayList<Host>(), size, monitors, 0);
+	}
+
+	/**
+	 * recursive built of all combinations of monitors with size "size"
+	 * 
+	 * @param current
+	 * @param max
+	 * @param monitors
+	 * @param posInMonitors
+	 * @return array of combinations
+	 */
+	private ArrayList<ArrayList<Host>> builtRecursive(ArrayList<Host> current, int max, ArrayList<Host> monitors, int posInMonitors) {
+		ArrayList<ArrayList<Host>> result = new ArrayList<ArrayList<Host>>();
+		if (current.size() == max) {
+			result.add(current);
+			return result;
+		} else {
+			for (int c = posInMonitors; c < monitors.size() - (max - current.size()); c++) {
+				ArrayList<Host> copy = (ArrayList<Host>) current.clone();
+				copy.add(monitors.get(c));
+				result.addAll(builtRecursive(copy, max, monitors, c + 1));
+			}
+			return result;
+		}
+	}
+
+	/**
+	 * generate two files with distance - rtt pairs, that can be used with
+	 * gnuplot
+	 * 
+	 * filename.txt1 plots each measured host - monitor RTT filename.txt2
+	 * aggregates distances within a range and calculates the average RTT
+	 * 
+	 * @param filename
+	 * @param steps
+	 *            number of divisions within the 0 - 20000km for aggregated plot
+	 */
+	public void distanceVsRttPlot(String filename, Host monitor, int steps) {
+		try {
+			double[] test1 = new double[steps];
+			int[] test2 = new int[steps];
+
+			FileWriter all = new FileWriter(filename + ".txt1");
+			for (Host host : hostIndex.values()) {
+				for (Host mon : host.getMeasuredMonitors()) {
+					double distance = getGeographicalDistance(host, mon);
+					double rtt = host.getRtt(mon);
+					all.write(distance + " " + rtt + "\n");
+
+					int pos = (int) Math.floor((distance / 20000.0) * steps);
+					test1[pos] += rtt;
+					test2[pos]++;
+				}
+			}
+			all.close();
+			all = new FileWriter(filename + ".txt2");
+			for (int c = 0; c < steps; c++) {
+				double x = (c * (20000.0 / steps)) + (20000.0 / (2 * steps));
+				double y = test1[c] / test2[c];
+				all.write(x + " " + y + "\n");
+			}
+			all.close();
+
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * saves host postion location, GNP position, groups, GNP Space, PingER
+	 * Lookup table in an xml file used within the simulation
+	 * 
+	 * @param file
+	 */
+	public void exportToXml(File file) {
+		try {
+			OutputFormat format = OutputFormat.createPrettyPrint();
+			OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
+			XMLWriter writer = new XMLWriter(out, format);
+			writer.write(getDocument());
+			writer.close();
+		} catch (IOException e) {
+			System.out.println(e);
+		}
+	}
+
+	/**
+	 * 
+	 * @return xml Document Object of relevant Class Attributes
+	 */
+	private Document getDocument() {
+		Set<Host> hosts = new HashSet<Host>();
+
+		// "GroupLookup" Element
+		DefaultElement groups = new DefaultElement("GroupLookup");
+		for (String group : this.groups.keySet()) {
+			hosts.addAll(this.groups.get(group));
+			DefaultElement peerXml = new DefaultElement("Group");
+			peerXml.addAttribute("id", group);
+			peerXml.addAttribute("maxsize", String.valueOf(this.groups.get(group).size()));
+			String ip = "";
+			int x = 0;
+			int blockSize = 1000;
+			// IP Block of 1000, too long blocks leads to hangUp ??
+			for (Host host : this.groups.get(group)) {
+				x++;
+				ip += "," + host.getIpAddress();
+				if (x % blockSize == 0) {
+					ip = ip.substring(1);
+					DefaultElement ips = new DefaultElement("IPs");
+					ips.addAttribute("value", ip);
+					peerXml.add(ips);
+					ip = "";
+				}
+			}
+			if (ip.length() > 0) {
+				ip = ip.substring(1);
+				DefaultElement ips = new DefaultElement("IPs");
+				ips.addAttribute("value", ip);
+				peerXml.add(ips);
+			}
+			groups.add(peerXml);
+		}
+
+		// "Hosts" Element
+		DefaultElement peers = new DefaultElement("Hosts");
+		for (Host host : hosts) {
+			DefaultElement peer = new DefaultElement("Host");
+			peer.addAttribute("ip", String.valueOf(host.getIpAddress()));
+
+			String area = (host.getArea() != null) ? host.getArea() : "--";
+			peer.addAttribute("continentalArea", area);
+
+			String countryCode = (host.getCountryCode() != null) ? host.getCountryCode() : "--";
+			peer.addAttribute("countryCode", countryCode);
+
+			String region = (host.getRegion() != null) ? host.getRegion() : "--";
+			peer.addAttribute("region", region);
+
+			String city = (host.getCity() != null) ? host.getCity() : "--";
+			peer.addAttribute("city", city);
+
+			String isp = (host.getISP() != null) ? host.getISP() : "--";
+			peer.addAttribute("isp", isp);
+
+			peer.addAttribute("longitude", String.valueOf(host.getLongitude()));
+			peer.addAttribute("latitude", String.valueOf(host.getLatitude()));
+			String coordinates = (host.getGnpPositionReference() != null) ? host.getGnpPositionReference().getCoordinateString() : "0";
+			peer.addAttribute("coordinates", coordinates);
+			peers.add(peer);
+		}
+
+		// "PingErLookup" Elements
+		Element pingEr = pingErLookup.exportToXML();
+
+		// "CountryLookup" Element
+		Element country = countryLookup.exportToXML();
+
+		DefaultDocument document = new DefaultDocument(new DefaultElement("gnp"));
+		document.getRootElement().add(groups);
+		document.getRootElement().add(peers);
+		document.getRootElement().add(pingEr);
+		document.getRootElement().add(country);
+		return document;
+
+	}
+	
+	public void insertIntoRelationalDB(NetMeasurementDB db) {
+		
+		Map<Host, NetMeasurementDB.Host> hostsScanned = new HashMap<Host, NetMeasurementDB.Host>();
+		
+		for (String group : this.groups.keySet()) {
+			
+			Set<Host> hosts = this.groups.get(group);
+			
+			List<NetMeasurementDB.Host> dbHosts = new ArrayList<NetMeasurementDB.Host>(hosts.size());
+			
+			for (Host h : hosts) {
+				
+				NetMeasurementDB.Host host = hostsScanned.get(h);
+				
+				if (host == null) {
+					
+					String countryStr = h.getCountryName();
+					String pingErRegionStr = countryLookup.getPingErRegionName(countryStr);
+					assert pingErRegionStr != null : "No PingEr region found for country " + countryStr;
+					City city = getCity(db, h.getCity(), h.getRegion(), countryStr, h.getCountryCode(), h.getArea(), pingErRegionStr);
+					
+					GnpPosition pos = h.getGnpPositionReference();
+					List<Double> gnpCoords;
+					if (pos != null) {
+						int dims = pos.getNoOfDimensions();
+						gnpCoords = new ArrayList<Double>(dims);
+						for (int i= 0; i<dims; i++) gnpCoords.add(pos.getGnpCoordinates(i));
+					} else {
+						gnpCoords = Collections.emptyList();
+					}
+					host = db.new Host(h.getIpAddress(), city, h.getLatitude(), h.getLongitude(), gnpCoords);
+					hostsScanned.put(h, host);
+				}
+			
+				dbHosts.add(host);
+				
+			}
+			
+			db.new Group(group, dbHosts);
+			
+		}
+
+		pingErLookup.insertIntoRelationalDB(db);
+	}
+	
+	public static City getCity(NetMeasurementDB db, String cityStr, String regionStr, String countryStr, String countryCode, String continentStr, String pingErRgName) {
+		//the host never occured in a group before. Putting it into the DB.
+		//FIXME: some cities or regions occur multiple times but in different regions/countries, we will have to separate them! Infers problem of DB structure.
+		City city = db.getStringAddrObjFromStr(City.class, cityStr);
+		if (city == null) {
+			Region region = db.getStringAddrObjFromStr(Region.class, regionStr);
+			if (region == null) {
+				Country country = db.getStringAddrObjFromStr(Country.class, countryStr);
+				if (country == null) {
+					Continent continent = db.getStringAddrObjFromStr(Continent.class, continentStr);
+					if (continent == null) continent = db.new Continent(continentStr);
+					
+					PingErRegion pErRegion = db.getStringAddrObjFromStr(PingErRegion.class, pingErRgName);
+					if (pErRegion == null) pErRegion = db.new PingErRegion(pingErRgName);
+					country = db.new Country(countryStr, continent, pErRegion, countryCode);
+				}
+				region = db.new Region(regionStr, country);
+			}
+			city = db.new City(cityStr, region);
+		}
+		return city;
+	}
+
+	/**
+	 * Comparator implementation for sorting of Host with the geographical
+	 * distance to a given position
+	 */
+	private class PeerComparatorDistance implements Comparator<Host> {
+
+		double latitude;
+
+		double longitude;
+
+		public void setPosition(double latitude, double longitude) {
+			this.latitude = latitude;
+			this.longitude = longitude;
+		}
+
+		public int compare(Host peer1, Host peer2) {
+			double distance1 = HostMap.getGeographicalDistance(peer1.getLatitude(), peer1.getLongitude(), latitude, longitude);
+			double distance2 = HostMap.getGeographicalDistance(peer2.getLatitude(), peer2.getLongitude(), latitude, longitude);
+			if (distance1 < distance2)
+				return -1;
+			else if (distance1 > distance2)
+				return 1;
+			else
+				return 0;
+		}
+	}
+
+	/**
+	 * Comparator implementation for sorting of Host with the number of measured
+	 * RTTs per Host.
+	 */
+	private class PeerComparatorNoOfConnections implements Comparator<Host> {
+		public int compare(Host peer1, Host peer2) {
+			int coonections1 = peer1.getMeasuredMonitors().size();
+			int coonections2 = peer2.getMeasuredMonitors().size();
+			if (coonections1 < coonections2)
+				return 1;
+			else if (coonections1 > coonections2)
+				return -1;
+			else
+				return 0;
+		}
+	}
+}

src/de/tud/kom/p2psim/impl/network/modular/ModularNetLayer.java

@@ -23,7 +23,6 @@ package de.tud.kom.p2psim.impl.network.modular;
 import java.util.Collection;
 
 import de.tud.kom.p2psim.api.analyzer.MessageAnalyzer.Reason;
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.common.SimHost;
 import de.tud.kom.p2psim.api.network.BandwidthImpl;
 import de.tud.kom.p2psim.api.network.NetMessage;
@@ -54,6 +53,7 @@ import de.tudarmstadt.maki.simonstrator.api.Monitor;
 import de.tudarmstadt.maki.simonstrator.api.Monitor.Level;
 import de.tudarmstadt.maki.simonstrator.api.component.network.Bandwidth;
 import de.tudarmstadt.maki.simonstrator.api.component.network.NetID;
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
 
 /**
  * <p>
@@ -113,7 +113,8 @@ public class ModularNetLayer extends AbstractNetLayer {
 	 *            Device-Type of this Host
 	 */
 	ModularNetLayer(SimHost host, AbstractModularSubnet subnet,
-			BandwidthImpl maxBW, NetMeasurementDB.Host hostMeta, Position position,
+			BandwidthImpl maxBW, NetMeasurementDB.Host hostMeta,
+			Location position,
 			IPv4NetID id) {
 		super(host, id, maxBW, position, hostMeta);
 		this.subnet = subnet;

src/de/tud/kom/p2psim/impl/network/modular/st/PositioningStrategy.java

@@ -21,9 +21,9 @@
 
 package de.tud.kom.p2psim.impl.network.modular.st;
 
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.common.SimHost;
 import de.tud.kom.p2psim.impl.network.modular.db.NetMeasurementDB;
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
 
 /**
  * This strategy determines an abstract network position of a given host 
@@ -43,7 +43,7 @@ public interface PositioningStrategy extends ModNetLayerStrategy {
 	 * @param hostMeta
 	 * @return
 	 */
-	public Position getPosition(
+	public Location getPosition(
 			SimHost host,
 			NetMeasurementDB db,
 			NetMeasurementDB.Host hostMeta);

src/de/tud/kom/p2psim/impl/network/modular/st/latency/FootprintLatency.java

@@ -30,7 +30,8 @@ public class FootprintLatency implements LatencyStrategy {
 			throw new IllegalArgumentException("FootprintLatency is incompatible with the NetMeasurementDB");
 		}
 
-		double distance = nlSender.getNetPosition().getDistance(nlReceiver.getNetPosition());
+		double distance = nlSender.getNetPosition()
+				.distanceTo(nlReceiver.getNetPosition());
 
 		return (staticPart + Math.round(geoDistFactor * distance))
 				* Time.MILLISECOND;

src/de/tud/kom/p2psim/impl/network/modular/st/latency/SimpleLatencyModel.java

@@ -19,12 +19,11 @@
  */
 
 
-
-package de.tud.kom.p2psim.impl.network.modular.st.latency;
-
+
+package de.tud.kom.p2psim.impl.network.modular.st.latency;
+
 import java.util.Random;
 
-import de.tud.kom.p2psim.api.common.Position;
 import de.tud.kom.p2psim.api.network.NetLayer;
 import de.tud.kom.p2psim.api.network.NetMessage;
 import de.tud.kom.p2psim.impl.network.AbstractNetLayer;
@@ -33,50 +32,51 @@ import de.tud.kom.p2psim.impl.network.modular.st.LatencyStrategy;
 import de.tud.kom.p2psim.impl.network.simple.SimpleSubnet;
 import de.tudarmstadt.maki.simonstrator.api.Randoms;
 import de.tudarmstadt.maki.simonstrator.api.Time;
-
-/**
- * This model is abstracting the details of the four lower OSI layers (UDP and
- * TCP) from the end-to-end connections between peers although important network
- * characteristics, like the geographical distance between peers, the processing
- * delay of intermediate systems, signal propagation, congestions,
- * retransmission and packet loss are incorporated into it. The message delay is
- * calculated using the following formula:
- * 
- * Message delay = f * (df + dist/v)
- * 
- * where dist - describes the geographical distance between the start and the
- * end point of the transmission, df - represents the processing delay of the
- * intermediate systems, v - stands for the speed of the signal propagation
- * through the transmission medium, and f - is a variable part which
- * encapsulates the retransmission, congestion.
- * 
- * @author Sebastian Kaune
- * 
- */
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
+
+/**
+ * This model is abstracting the details of the four lower OSI layers (UDP and
+ * TCP) from the end-to-end connections between peers although important network
+ * characteristics, like the geographical distance between peers, the processing
+ * delay of intermediate systems, signal propagation, congestions,
+ * retransmission and packet loss are incorporated into it. The message delay is
+ * calculated using the following formula:
+ * 
+ * Message delay = f * (df + dist/v)
+ * 
+ * where dist - describes the geographical distance between the start and the
+ * end point of the transmission, df - represents the processing delay of the
+ * intermediate systems, v - stands for the speed of the signal propagation
+ * through the transmission medium, and f - is a variable part which
+ * encapsulates the retransmission, congestion.
+ * 
+ * @author Sebastian Kaune
+ * 
+ */
 public class SimpleLatencyModel implements LatencyStrategy {
 
-	private Random rnd = Randoms.getRandom(SimpleLatencyModel.class);
-
-	/**
-	 * Speed in kilometer per second
-	 */
-	private final int signalSpeed = 100000;
-
-	/**
-	 * Earth circumference in kilometres
-	 */
-	private final int earth_circumference = 40000;
-
-	private final double relSignalSpeed;
-
-	/**
-	 * Constructor
-	 * 
-	 */
-	public SimpleLatencyModel() {
-		relSignalSpeed = signalSpeed * (SimpleSubnet.SUBNET_WIDTH / earth_circumference);
-	}
-
+	private Random rnd = Randoms.getRandom(SimpleLatencyModel.class);
+
+	/**
+	 * Speed in kilometer per second
+	 */
+	private final int signalSpeed = 100000;
+
+	/**
+	 * Earth circumference in kilometres
+	 */
+	private final int earth_circumference = 40000;
+
+	private final double relSignalSpeed;
+
+	/**
+	 * Constructor
+	 * 
+	 */
+	public SimpleLatencyModel() {
+		relSignalSpeed = signalSpeed * (SimpleSubnet.SUBNET_WIDTH / earth_circumference);
+	}
+
 	/**
 	 * Gets the distance.
 	 *
@@ -84,12 +84,12 @@ public class SimpleLatencyModel implements LatencyStrategy {
 	 * @param receiver the receiver
 	 * @return the distance
 	 */
-	public double getDistance(NetLayer sender, NetLayer receiver) {
-		Position ps = sender.getNetPosition();
-		Position pr = receiver.getNetPosition();
-		return ps.getDistance(pr);
-	}
-
+	public double getDistance(NetLayer sender, NetLayer receiver) {
+		Location ps = sender.getNetPosition();
+		Location pr = receiver.getNetPosition();
+		return ps.distanceTo(pr);
+	}
+
 	/**
 	 * Calc static delay.
 	 *
@@ -97,9 +97,9 @@ public class SimpleLatencyModel implements LatencyStrategy {
 	 * @param distance the distance
 	 * @return the double
 	 */
-	public double calcStaticDelay(NetLayer receiver, double distance) {
-		int df = Math.abs(receiver.hashCode() % 31);
-		return (df + (distance / relSignalSpeed) * 1000);
+	public double calcStaticDelay(NetLayer receiver, double distance) {
+		int df = Math.abs(receiver.hashCode() % 31);
+		return (df + (distance / relSignalSpeed) * 1000);
 	}
 
 	@Override
@@ -119,6 +119,6 @@ public class SimpleLatencyModel implements LatencyStrategy {
 	@Override
 	public void writeBackToXML(BackWriter bw) {
 		// None.
-	}
-
+	}
+
 }
\ No newline at end of file

src/de/tud/kom/p2psim/impl/network/modular/st/latency/SimpleStaticLatencyModel.java

@@ -19,36 +19,36 @@
  */
 
 
-
-package de.tud.kom.p2psim.impl.network.modular.st.latency;
-
 
-import de.tud.kom.p2psim.api.common.Position;
+package de.tud.kom.p2psim.impl.network.modular.st.latency;
+
+
 import de.tud.kom.p2psim.api.network.NetMessage;
 import de.tud.kom.p2psim.impl.network.AbstractNetLayer;
 import de.tud.kom.p2psim.impl.network.modular.db.NetMeasurementDB;
 import de.tud.kom.p2psim.impl.network.modular.st.LatencyStrategy;
 import de.tudarmstadt.maki.simonstrator.api.Time;
-
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
+
 public class SimpleStaticLatencyModel implements LatencyStrategy {
-	
-	protected long propagationDelay = 10; // 10 ms
-
-	public SimpleStaticLatencyModel(long staticLatency) {
-		this.setLatency(staticLatency);
-	}
-
-	/**
-	 * Sets the static latency which is expected in millseconds. That is, if
-	 * <code>staticLatency</code> is set to 10, the simulator will translate it
-	 * into simulation units as follows: staticLatency *
-	 * Simulator.MILLISECOND_UNIT.
-	 * 
-	 * @param staticLatency
-	 *            the static latency in milliseconds.
-	 */
-	public void setLatency(long staticLatency) {
-		this.propagationDelay = staticLatency;
+	
+	protected long propagationDelay = 10; // 10 ms
+
+	public SimpleStaticLatencyModel(long staticLatency) {
+		this.setLatency(staticLatency);
+	}
+
+	/**
+	 * Sets the static latency which is expected in millseconds. That is, if
+	 * <code>staticLatency</code> is set to 10, the simulator will translate it
+	 * into simulation units as follows: staticLatency *
+	 * Simulator.MILLISECOND_UNIT.
+	 * 
+	 * @param staticLatency
+	 *            the static latency in milliseconds.
+	 */
+	public void setLatency(long staticLatency) {
+		this.propagationDelay = staticLatency;
 	}
 	
 	/**
@@ -60,13 +60,13 @@ public class SimpleStaticLatencyModel implements LatencyStrategy {
 	 */
 	protected double getDistance(AbstractNetLayer nlSender, AbstractNetLayer nlReceiver){
 			
-		Position ps = nlSender.getNetPosition();
-		Position pr = nlReceiver.getNetPosition();
+		Location ps = nlSender.getNetPosition();
+		Location pr = nlReceiver.getNetPosition();
 		
-		return ps.getDistance(pr);
+		return ps.distanceTo(pr);
 		
 	}
-	
+	
 
 	/* (non-Javadoc)
 	 * @see de.tud.kom.p2psim.impl.network.modular.st.LatencyStrategy#getMessagePropagationDelay(de.tud.kom.p2psim.api.network.NetMessage, de.tud.kom.p2psim.impl.network.AbstractNetLayer, de.tud.kom.p2psim.impl.network.AbstractNetLayer, de.tud.kom.p2psim.impl.network.modular.db.NetMeasurementDB)
@@ -85,6 +85,6 @@ public class SimpleStaticLatencyModel implements LatencyStrategy {
 	@Override
 	public void writeBackToXML(BackWriter bw) {
 		bw.writeTime("propagationDelay", propagationDelay);
-	}
-
-}
+	}
+
+}