More abstraction to assignment strategies.

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/groups/groupforming/AbstractGroupForming.java

@@ -102,9 +102,9 @@ public abstract class AbstractGroupForming implements IGroupFormingBehavior {
 						"GroupForming: groupFormationSetupDelay must be > 0!");
 			}
 			
-			if (groupFormationDelay < 0) {
+			if (groupFormationDelay < -1) {
 				throw new ConfigurationException(
-						"GroupForming: groupFormationDelay must be >= 1!");
+						"GroupForming: groupFormationDelay must be >= -1!");
 			}
 			
 			if (groupRejoinWaitTime < 0) {
@@ -218,14 +218,28 @@ public abstract class AbstractGroupForming implements IGroupFormingBehavior {
 	public void removeGroup(SocialMovementGroup group) {
 		groupCon.removeGroup(group);
 		
-		Event.scheduleWithDelay(rndGroupFormationDelay(), new EventHandler() {			
+		long delay = 0;
+		
+		if(groupFormationDelay == -1) {
+			delay = movementModel.getAttractionAssignmentStrategy().getPauseTime(group.getLeader().getCurrentTargetAttractionPoint());
+		}
+		else {
+			delay = rndGroupFormationDelay();
+		}
+		
+		System.out.println(Time.getFormattedTime(delay));
+		
+		Event.scheduleWithDelay(delay, new EventHandler() {			
 			@Override
 			public void eventOccurred(Object content, int type) {
-				triggerGroupFormation();				
+				assembleGroup();		
 			}
 		}, null, 0);
 	}
 
+	protected abstract void assembleGroup();
+	
+	
 	/**
 	 * Returns the first AttractionPoint which contains the host with the greatest stayDuration of all hosts located in AttractionPoints.
 	 * 

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/groups/groupforming/DefaultGroupForming.java

@@ -94,12 +94,18 @@ public class DefaultGroupForming extends AbstractGroupForming {
 		System.out.println(Time.getFormattedTime() + " | group trigger " + groupsToCreate);
 		
 		for(int g = 0; g < groupsToCreate; g++) {
+			assembleGroup();
+		}
+	}
+
+	@Override
+	protected void assembleGroup() {
 		// Get attractionPoint with highest amount of hosts
 		hostCounter.updateHostCount();
 		
 		AttractionPoint apCandidate = IAttractionGenerator.attractionPoints.get(rand.nextInt(IAttractionGenerator.attractionPoints.size()));
 		if(apCandidate == null) {
-				break;
+			return;
 		}
 
 		int numberOfHostsInAttractionPoint = hostCounter.getHostCountOfAttractionPoint(apCandidate);		
@@ -146,11 +152,11 @@ public class DefaultGroupForming extends AbstractGroupForming {
 			Event.scheduleWithDelay(Time.MINUTE, new EventHandler() {			
 				@Override
 				public void eventOccurred(Object content, int type) {
-						triggerGroupFormation();				
+					assembleGroup();			
 				}
 			}, null, 0);
 			
-				break;
+			return;
 		}
 								
 		for(SimLocationActuator candidate : groupCandidates) {
@@ -160,7 +166,6 @@ public class DefaultGroupForming extends AbstractGroupForming {
 		
 		createGroup(groupCandidates);
 	}
-	}
 	
 	/* 
 	 * =====================================================================================================

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/groups/groupforming/IGroupFormingBehavior.java

@@ -20,7 +20,6 @@
 
 package de.tud.kom.p2psim.impl.topology.movement.modularosm.groups.groupforming;
 
-import de.tud.kom.p2psim.api.topology.movement.SimLocationActuator;
 import de.tud.kom.p2psim.impl.topology.movement.modularosm.SocialGroupMovementModel;
 import de.tud.kom.p2psim.impl.topology.movement.modularosm.groups.SocialMovementGroup;
 

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/transition/AbstractAttractionBasedAssignmentStrategy.java

@@ -52,6 +52,14 @@ public abstract class AbstractAttractionBasedAssignmentStrategy implements IAttr
 	
 	protected final static int EVENT_PAUSE_ENDED = 1;
 	
+	public AbstractAttractionBasedAssignmentStrategy(long defaultPauseTimeMin, long defaultPauseTimeMax) {
+		assert defaultPauseTimeMax >= 0 && defaultPauseTimeMin >= 0;
+		assert defaultPauseTimeMax >= defaultPauseTimeMin;
+		
+		this.defaultPauseTimeMax = defaultPauseTimeMax;
+		this.defaultPauseTimeMin = defaultPauseTimeMin;
+	}
+	
 	@Override
 	public AttractionPoint getAssignment(SimLocationActuator comp) {
 		return assignments.get(comp);
@@ -101,7 +109,7 @@ public abstract class AbstractAttractionBasedAssignmentStrategy implements IAttr
 		}		
 	}
 	
-	protected long getPauseTime(AttractionPoint attractionPoint) {
+	public long getPauseTime(AttractionPoint attractionPoint) {
 		return getRandomUniformDistributionPauseTime(attractionPoint);
 	}	
 		

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/transition/AttractionPointRoamingStrategy.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.impl.topology.movement.modularosm.transition;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import de.tud.kom.p2psim.api.topology.movement.SimLocationActuator;
+import de.tud.kom.p2psim.impl.topology.movement.modularosm.ModularMovementModel;
+import de.tud.kom.p2psim.impl.topology.movement.modularosm.attraction.IAttractionGenerator;
+import de.tudarmstadt.maki.simonstrator.api.Event;
+import de.tudarmstadt.maki.simonstrator.api.EventHandler;
+import de.tudarmstadt.maki.simonstrator.api.Time;
+import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.AttractionPoint;
+import de.tudarmstadt.maki.simonstrator.api.util.XMLConfigurableConstructor;
+
+/**
+ * With this transition strategy, nodes are roaming around {@link AttractionPoint}s, without transitions between them. As the {@link ModularMovementModel} 
+ * uses a Gauss function to add jitter and offsets to the movement, some nodes may also roam outside of the circle's radius (this is intended to make it more realistic)
+ * 
+ * @author Julian Zobel
+ * @version 1.0, 24.01.2019
+ */
+public class AttractionPointRoamingStrategy extends AbstractAttractionBasedAssignmentStrategy implements EventHandler {
+
+	public static enum roamingTransitionState {
+		PAUSE,
+		ROAMING
+	}	
+	
+	protected Map<SimLocationActuator, roamingTransitionState> roamingStates = new LinkedHashMap<>();
+	
+	@XMLConfigurableConstructor({ "defaultPauseTimeMin", "defaultPauseTimeMax" })
+	public AttractionPointRoamingStrategy(long defaultPauseTimeMin, long defaultPauseTimeMax) {
+		super(defaultPauseTimeMin, defaultPauseTimeMax);
+	}
+	
+	@Override
+	public void addComponent(SimLocationActuator comp) {
+		this.roamingStates.put(comp, null);	
+		AttractionPoint nextAP = getNewAttractionPointAssignment(comp);
+		updateTargetAttractionPoint(comp, nextAP);
+	}
+
+	@Override
+	public void reachedAttractionPoint(SimLocationActuator comp, AttractionPoint attractionPoint) {
+		
+		if(roamingStates.get(comp) == roamingTransitionState.PAUSE) {
+			return;
+		}
+				
+		this.roamingStates.put(comp, roamingTransitionState.PAUSE);
+		// schedule roaming
+		Event.scheduleWithDelay(Math.max(Time.MINUTE, gaussianDistributionPauseTime(5 * Time.MINUTE, 1 * Time.MINUTE)), this, comp, 0);	
+			
+	}	
+		
+	/**
+	 * Use a gaussian distribution for the pause time interval generation, using a mean value and a standard deviation
+	 * 
+	 * @return
+	 */
+	private long gaussianDistributionPauseTime(double mean, double std) {		
+		double x = rnd.nextGaussian() * std + mean;	
+		if(x <= 0) return gaussianDistributionPauseTime(mean, std*0.9);		
+		return (long) x;		
+	}
+	
+	private void roamAroundAttractionPoint(SimLocationActuator comp) {
+		if(roamingStates.get(comp) == roamingTransitionState.PAUSE) {
+			AttractionPoint currentAttractionPoint = this.assignments.get(comp);			
+			this.roamingStates.put(comp, roamingTransitionState.ROAMING);				
+			notifyListenersOfAssignmentUpdate(comp, currentAttractionPoint);
+			
+		}		
+	}
+	
+	@Override
+	public void eventOccurred(Object content, int type) {
+	
+		SimLocationActuator comp = (SimLocationActuator) content;			
+		AttractionPoint currentAttractionPoint = this.assignments.get(comp);
+		
+		// if the attraction point was removed in the meantime, go directly to transit state
+		if(currentAttractionPoint == null || !IAttractionGenerator.attractionPoints.contains(currentAttractionPoint)) {				
+			this.addComponent(comp);
+		}
+		else {			
+			this.roamAroundAttractionPoint(comp);
+		}		
+	}	
+	
+	
+	
+}

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/transition/FixedAssignmentStrategy.java

@@ -40,6 +40,10 @@ import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Attraction
  */
 public class FixedAssignmentStrategy extends AbstractAttractionBasedAssignmentStrategy {
 	
+	public FixedAssignmentStrategy() {
+		super(0, 0);
+	}
+
 	private List<SimLocationActuator> comps = new LinkedList<SimLocationActuator>();
 	
 	private Map<SimLocationActuator, SimHost> mappingMSHost = new LinkedHashMap<SimLocationActuator, SimHost>();

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/transition/IAttractionAssigmentStrategy.java

@@ -87,4 +87,5 @@ public interface IAttractionAssigmentStrategy {
 		
 	public boolean hostInAttractionPointArea(SimLocationActuator host);
 	
+	public long getPauseTime(AttractionPoint attractionPoint);
 }

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/transition/InAreaRoamingTransitionStrategy.java

@@ -54,11 +54,7 @@ public class InAreaRoamingTransitionStrategy extends AbstractAttractionBasedAssi
 	
 	@XMLConfigurableConstructor({ "defaultPauseTimeMin", "defaultPauseTimeMax" })
 	public InAreaRoamingTransitionStrategy(long defaultPauseTimeMin, long defaultPauseTimeMax) {
-		assert defaultPauseTimeMax >= 0 && defaultPauseTimeMin >= 0;
-		assert defaultPauseTimeMax >= defaultPauseTimeMin;
-		
-		this.defaultPauseTimeMax = defaultPauseTimeMax;
-		this.defaultPauseTimeMin = defaultPauseTimeMin;
+		super(defaultPauseTimeMin, defaultPauseTimeMax);
 	}
 	
 	@Override
@@ -88,7 +84,7 @@ public class InAreaRoamingTransitionStrategy extends AbstractAttractionBasedAssi
 	}	
 		
 	@Override
-	protected long getPauseTime(AttractionPoint attractionPoint) {
+	public long getPauseTime(AttractionPoint attractionPoint) {
 		if(useGaussianDistributedPauseTime) {
 			return gaussianDistributionPauseTime(defaultPauseTimeMax - defaultPauseTimeMin, 0.5*(defaultPauseTimeMax - defaultPauseTimeMin));
 		}

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/transition/ManualAssignmentStrategy.java

@@ -15,6 +15,10 @@ import java.util.*;
  */
 public class ManualAssignmentStrategy extends AbstractAttractionBasedAssignmentStrategy
 {
+    public ManualAssignmentStrategy() {
+		super(0, 0);
+	}
+
 	private LinkedHashSet<AttractionPoint> aPoints = new LinkedHashSet<>();
 
     private Map<SimLocationActuator, AttractionPoint> assignments = new HashMap<>();

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/transition/RandomInAreaTransitionStrategy.java

@@ -27,6 +27,10 @@ import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
  */
 public class RandomInAreaTransitionStrategy extends AbstractAttractionBasedAssignmentStrategy
 {   
+    public RandomInAreaTransitionStrategy() {
+		super(0, 0);
+	}
+
 	/**
      * These are the current spots inside the target area where the client is currently heading.
      */

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/transition/SocialTransitionStrategy.java

@@ -104,11 +104,7 @@ public class SocialTransitionStrategy extends AbstractAttractionBasedAssignmentS
 
 	@XMLConfigurableConstructor({ "defaultPauseTimeMin", "defaultPauseTimeMax" })
 	public SocialTransitionStrategy(long defaultPauseTimeMin, long defaultPauseTimeMax) {
-		assert defaultPauseTimeMax >= 0 && defaultPauseTimeMin >= 0;
-		assert defaultPauseTimeMax >= defaultPauseTimeMin;
-		
-		this.defaultPauseTimeMax = defaultPauseTimeMax;
-		this.defaultPauseTimeMin = defaultPauseTimeMin;
+		super(defaultPauseTimeMin, defaultPauseTimeMax);
 	}
 
 	

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/transition/WeightedTransitionStrategy.java

@@ -43,11 +43,7 @@ public class WeightedTransitionStrategy extends AbstractAttractionBasedAssignmen
 			
 	@XMLConfigurableConstructor({ "defaultPauseTimeMin", "defaultPauseTimeMax" })
 	public WeightedTransitionStrategy(long defaultPauseTimeMin, long defaultPauseTimeMax) {
-		assert defaultPauseTimeMax >= 0 && defaultPauseTimeMin >= 0;
-		assert defaultPauseTimeMax >= defaultPauseTimeMin;
-		
-		this.defaultPauseTimeMax = defaultPauseTimeMax;
-		this.defaultPauseTimeMin = defaultPauseTimeMin;
+		super(defaultPauseTimeMin, defaultPauseTimeMax);
 	}
 	
 	@Override