PureEdgeSim -locationmanager包-MobilityModel文件

MobilityModel

移动管理器模块的主类，为不同的边缘设备生成移动路径。

---

当前设备的位置

    protected Location currentLocation;

设备是否移动

    protected boolean isMobile = false;

最小暂停持续时间

	protected double minPauseDuration;

最大暂停持续时间

	protected double maxPauseDuration;

最大移动持续时间

	protected double maxMobilityDuration;

最小移动持续时间

	protected double minMobilityDuration;

速度

	protected double speed;

仿真管理器

	protected SimulationManager simulationManager;

最近的边缘数据中心

	protected ComputingNode closestEdgeDataCenter = ComputingNode.NULL;

每过一个时间间隔的位置

	Map<Integer, Location> path = new LinkedHashMap<>(
			(int) (SimulationParameters.simulationDuration / SimulationParameters.updateInterval));

每过一个间隔的最近的边缘数据中心

	Map<Integer, ComputingNode> datacentersMap = new LinkedHashMap<>(
			(int) (SimulationParameters.simulationDuration / SimulationParameters.updateInterval));

初始化空移动模型,防止空指针

	/**
	 * An attribute that implements the Null Object Design Pattern to avoid
	 * NullPointerException when using the NULL object instead of attributing null
	 * to MobilityModel variables.
	 */
	public static final MobilityModel NULL = new MobilityModelNull();

初始化对象

	protected MobilityModel(SimulationManager simulationManager, Location location) {
		currentLocation = location;
		setSimulationManager(simulationManager);
	}
	protected MobilityModel() {
	}

返回下一一时刻XY位置

	protected abstract Location getNextLocation(Location location);

更新位置

	public Location updateLocation(double time) {
		if (time <= SimulationParameters.simulationDuration)
			currentLocation = path.get((int) time * 1000);
		return currentLocation;
	}

得到当前位置

	public Location getCurrentLocation() {
		return currentLocation;
	}

获得是否是移动模型

	public boolean isMobile() {
		return isMobile;
	}

设置是否是移动模型

	public MobilityModel setMobile(boolean mobile) {
		isMobile = mobile;
		return this;
	}

得到最小的连续暂停周期

	public double getMinPauseDuration() {
		return minPauseDuration;
	}

设置最小的连续暂停周期

	public MobilityModel setMinPauseDuration(double minPauseDuration) {
		this.minPauseDuration = minPauseDuration;
		return this;
	}

得到最大暂停周期

	public double getMaxPauseDuration() {
		return maxPauseDuration;
	}

设置最大暂停持续时间

	public MobilityModel setMaxPauseDuration(double maxPauseDuration) {
		this.maxPauseDuration = maxPauseDuration;
		return this;
	}

得到最小移动持续时间

	public double getMinMobilityDuration() {
		return minMobilityDuration;
	}

设置最小移动持续时间

	public MobilityModel setMinMobilityDuration(double minMobilityDuration) {
		this.minMobilityDuration = minMobilityDuration;
		return this;
	}

得到最大移动持续时间

	public double getMaxMobilityDuration() {
		return maxMobilityDuration;
	}

设置最大移动持续时间

	public MobilityModel setMaxMobilityDuration(double maxMobilityDuration) {
		this.maxMobilityDuration = maxMobilityDuration;
		return this;
	}

得到速度

	public double getSpeed() {
		return speed;
	}

设置速度

	public MobilityModel setSpeed(double speed) {
		this.speed = speed;
		return this;
	}

计算节点的距离

	public double distanceTo(ComputingNode device2) {
		return Math.abs(Math.sqrt(Math
				.pow((getCurrentLocation().getXPos() - device2.getMobilityModel().getCurrentLocation().getXPos()), 2)
				+ Math.pow((getCurrentLocation().getYPos() - device2.getMobilityModel().getCurrentLocation().getYPos()),
						2)));
	}

得到仿真管理器

	public SimulationManager getSimulationManager() {
		return simulationManager;
	}

设置仿真管理器

	public void setSimulationManager(SimulationManager simulationManager) {
		this.simulationManager = simulationManager;
	}

生成路径

	public void generatePath() {

        closestEdgeDataCenter = getDataCenter();

        if (!isMobile())
            return;
        Location newLocation = getCurrentLocation();//获得当前位置

        // Working around the double imprecision
        int interval = (int) (SimulationParameters.updateInterval * 1000);//计算更新间隔
        int simulationTime = (int) (SimulationParameters.simulationDuration * 1000);//计算仿真时间

        for (int i = 0; i <= simulationTime; i = i + interval) {
            path.put(i, newLocation);//每过一个间隔在路径上插入新的位置
            newLocation = getNextLocation(newLocation);
            datacentersMap.put(i, getDataCenter());
        }
	}

得到最近距离的计算节点(内部函数调用)

	 protected ComputingNode getDataCenter() {
        List<ComputingNode> list = getSimulationManager().getDataCentersManager().getComputingNodesGenerator()
                .getEdgeOnlyList();//得到边缘数据中心列表

        double range = SimulationParameters.edgeDataCentersRange;//边缘数据中心连接范围
        ComputingNode closestDC = ComputingNode.NULL;

        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).isPeripheral() && distanceTo(list.get(i)) <= range) {//在边缘数据中心的传输范围内
                range = distanceTo(list.get(i));
                closestDC = list.get(i);
                //循环找到最小距离的边缘数据中心
            }
        }
        return closestDC;
    }

得到最近的计算节点(自己调用用这个)

	 public ComputingNode getClosestEdgeDataCenter() {
        return (isMobile //是否是移动设备
                && getSimulationManager().getSimulation().clock() <= SimulationParameters.simulationDuration)//是否在仿真时间内
                ? datacentersMap.get((int) (getSimulationManager().getSimulation().clock() * 1000))//得到当前位置最近的边缘数据中心
                : closestEdgeDataCenter;//最后时间最近数据中心的位置
    }