adjusted load updater to cope with multiple capacity dimensions

jsprit-core/src/main/java/jsprit/core/algorithm/state/StateManager.java

@@ -428,9 +428,9 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
 			UpdateLoads updateLoads = new UpdateLoads(this);
 			addActivityVisitor(updateLoads);
 			addListener(updateLoads);
-			addActivityVisitor(new UpdatePrevMaxLoad(this));
+			addActivityVisitor(new UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute(this));
-			addActivityVisitor(new UpdateMaxLoadForwardLooking(this));
+			addActivityVisitor(new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(this));
-			addActivityVisitor(new UpdateMaxLoad_(this));
+			addActivityVisitor(new UpdateMaxCapacityUtilisationAtRoute(this));
 		}
 	}
 

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateLoads.java

@@ -50,7 +50,7 @@ class UpdateLoads implements ActivityVisitor, StateUpdater, InsertionStartsListe
 
 	@Override
 	public void visit(TourActivity act) {
-		currentLoad = Capacity.addup(currentLoad, act.getCapacity());
+		currentLoad = Capacity.addup(currentLoad, act.getSize());
 		stateManager.putInternalActivityState_(act, StateFactory.LOAD, Capacity.class, currentLoad);
 		assert currentLoad.isLessOrEqual(route.getVehicle().getType().getCapacityDimensions()) : "currentLoad at activity must not be > vehicleCapacity";
 		assert currentLoad.isGreaterOrEqual(Capacity.Builder.newInstance().build()) : "currentLoad at act must not be < 0 in one of the applied dimensions";

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute.java

@@ -0,0 +1,44 @@
+package jsprit.core.algorithm.state;
+
+import jsprit.core.problem.Capacity;
+import jsprit.core.problem.solution.route.VehicleRoute;
+import jsprit.core.problem.solution.route.activity.ActivityVisitor;
+import jsprit.core.problem.solution.route.activity.TourActivity;
+import jsprit.core.problem.solution.route.state.StateFactory;
+
+/**
+ * Determines and memorizes the maximum capacity utilization at each activity by looking backward in route,
+ * i.e. the maximum capacity utilization at previous activities.
+ * 
+ * @author schroeder
+ *
+ */
+class UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute implements ActivityVisitor, StateUpdater {
+	
+	private StateManager stateManager;
+	
+	private VehicleRoute route;
+	
+	private Capacity maxLoad;
+	
+	public UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute(StateManager stateManager) {
+		this.stateManager = stateManager;
+	}
+
+	@Override
+	public void begin(VehicleRoute route) {
+		this.route = route;
+		maxLoad = stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class);
+	}
+
+	@Override
+	public void visit(TourActivity act) {
+		maxLoad = Capacity.max(maxLoad, stateManager.getActivityState(act, StateFactory.LOAD, Capacity.class));
+		stateManager.putInternalActivityState_(act, StateFactory.PAST_MAXLOAD, Capacity.class, maxLoad);
+		assert maxLoad.isGreaterOrEqual(Capacity.Builder.newInstance().build()) : "maxLoad can never be smaller than 0";
+		assert maxLoad.isLessOrEqual(route.getVehicle().getType().getCapacityDimensions()) : "maxLoad can never be bigger than vehicleCap";
+	}
+
+	@Override
+	public void finish() {}
+}

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute.java

@@ -0,0 +1,63 @@
+package jsprit.core.algorithm.state;
+
+import jsprit.core.problem.Capacity;
+import jsprit.core.problem.solution.route.VehicleRoute;
+import jsprit.core.problem.solution.route.activity.ReverseActivityVisitor;
+import jsprit.core.problem.solution.route.activity.TourActivity;
+import jsprit.core.problem.solution.route.state.StateFactory;
+
+/**
+ * A {@link ReverseActivityVisitor} that looks forward in the vehicle route and determines
+ * the maximum capacity utilization (in terms of loads) at subsequent activities. 
+ * 
+ * <p>Assume a vehicle route with the following activity sequence {start,pickup(1,4),delivery(2,3),pickup(3,2),end} where
+ * pickup(1,2) = pickup(id,cap-demand).<br> 
+ * Future maxLoad for each activity are calculated as follows:<br>
+ * loadAt(end)=6 (since two pickups need to be delivered to depot)<br>
+ * pickup(3)=max(loadAt(pickup(3)), futureMaxLoad(end))=max(6,6)=6
+ * delivery(2)=max(loadAt(delivery(2),futureMaxLoad(pickup(3))=max(4,6)=6
+ * pickup(1)=max(7,6)=7
+ * start=max(7,7)=7
+ * activity (apart from start and end), the maximum capacity is determined when forward looking into the route.
+ * That is at each activity we know how much capacity is available whithout breaking future capacity constraints.
+ * 
+ * 
+ * @author schroeder
+ *
+ */
+class UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute implements ReverseActivityVisitor, StateUpdater {
+	
+	private StateManager stateManager;
+	
+	private VehicleRoute route;
+	
+	private Capacity maxLoad = Capacity.Builder.newInstance().build();
+//	private double maxLoad;
+	
+	public UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(StateManager stateManager) {
+		super();
+		this.stateManager = stateManager;
+	}
+
+	@Override
+	public void begin(VehicleRoute route) {
+		this.route = route;
+		maxLoad = stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class);
+//		maxLoad = stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble();
+	}
+
+	@Override
+	public void visit(TourActivity act) {
+		maxLoad = Capacity.max(maxLoad, stateManager.getActivityState(act, StateFactory.LOAD, Capacity.class));
+//		maxLoad = Math.max(maxLoad, stateManager.getActivityState(act, StateFactory.LOAD).toDouble());
+		stateManager.putInternalActivityState_(act, StateFactory.FUTURE_MAXLOAD, Capacity.class, maxLoad);
+//		stateManager.putInternalActivityState(act, StateFactory.FUTURE_MAXLOAD, StateFactory.createState(maxLoad));
+		assert maxLoad.isLessOrEqual(route.getVehicle().getType().getCapacityDimensions()) : "maxLoad can in every capacity dimension never be bigger than vehicleCap";
+//		assert maxLoad <= route.getVehicle().getCapacity() : "maxLoad can never be bigger than vehicleCap";
+		assert maxLoad.isGreaterOrEqual(Capacity.Builder.newInstance().build()) : "maxLoad can never be smaller than 0";
+		//		assert maxLoad >= 0 : "maxLoad can never be smaller than 0";
+	}
+
+	@Override
+	public void finish() {}
+}

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateMaxCapacityUtilisationAtRoute.java

@@ -0,0 +1,52 @@
+package jsprit.core.algorithm.state;
+
+import jsprit.core.problem.Capacity;
+import jsprit.core.problem.solution.route.VehicleRoute;
+import jsprit.core.problem.solution.route.activity.ActivityVisitor;
+import jsprit.core.problem.solution.route.activity.TourActivity;
+import jsprit.core.problem.solution.route.state.StateFactory;
+
+/**
+ * Updates load at activity level. 
+ * 
+ * <p>Note that this assumes that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT.
+ * If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot.
+ * 
+ * <p>Thus it DEPENDS on StateTypes.LOAD_AT_DEPOT
+ *  
+ * @author stefan
+ *
+ */
+class UpdateMaxCapacityUtilisationAtRoute implements ActivityVisitor, StateUpdater {
+	
+	private StateManager stateManager;
+	
+	private Capacity currentLoad = Capacity.Builder.newInstance().build();
+	
+	private VehicleRoute route;
+	
+	private Capacity maxLoad = Capacity.Builder.newInstance().build();
+	
+	public UpdateMaxCapacityUtilisationAtRoute(StateManager stateManager) {
+		super();
+		this.stateManager = stateManager;
+	}
+	
+	@Override
+	public void begin(VehicleRoute route) {
+		currentLoad = stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class);
+		maxLoad = currentLoad;
+		this.route = route;
+	}
+
+	@Override
+	public void visit(TourActivity act) {
+		currentLoad = Capacity.addup(currentLoad, act.getSize());
+		maxLoad = Capacity.max(maxLoad, currentLoad);
+	}
+
+	@Override
+	public void finish() {
+		stateManager.putInternalRouteState_(route, StateFactory.MAXLOAD, Capacity.class, maxLoad);
+	}
+}

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateMaxLoadForwardLooking.java

@@ -1,46 +0,0 @@
-package jsprit.core.algorithm.state;
-
-import jsprit.core.problem.solution.route.VehicleRoute;
-import jsprit.core.problem.solution.route.activity.ReverseActivityVisitor;
-import jsprit.core.problem.solution.route.activity.TourActivity;
-import jsprit.core.problem.solution.route.state.StateFactory;
-
-/**
- * A {@link ReverseActivityVisitor} that looks forward in the vehicle route and determines
- * the maximum load for subsequent activities.
- * 
- * <p>
- * 
- * @author schroeder
- *
- */
-class UpdateMaxLoadForwardLooking implements ReverseActivityVisitor, StateUpdater {
-	
-	private StateManager stateManager;
-	
-	private VehicleRoute route;
-	
-	private double maxLoad;
-	
-	public UpdateMaxLoadForwardLooking(StateManager stateManager) {
-		super();
-		this.stateManager = stateManager;
-	}
-
-	@Override
-	public void begin(VehicleRoute route) {
-		this.route = route;
-		maxLoad = stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble();
-	}
-
-	@Override
-	public void visit(TourActivity act) {
-		maxLoad = Math.max(maxLoad, stateManager.getActivityState(act, StateFactory.LOAD).toDouble());
-		stateManager.putInternalActivityState(act, StateFactory.FUTURE_MAXLOAD, StateFactory.createState(maxLoad));
-		assert maxLoad <= route.getVehicle().getCapacity() : "maxLoad can never be bigger than vehicleCap";
-		assert maxLoad >= 0 : "maxLoad can never be smaller than 0";
-	}
-
-	@Override
-	public void finish() {}
-}

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateMaxLoad_.java

@@ -1,68 +0,0 @@
-package jsprit.core.algorithm.state;
-
-import jsprit.core.problem.solution.route.VehicleRoute;
-import jsprit.core.problem.solution.route.activity.ActivityVisitor;
-import jsprit.core.problem.solution.route.activity.TourActivity;
-import jsprit.core.problem.solution.route.state.StateFactory;
-
-/**
- * Updates load at activity level. 
- * 
- * <p>Note that this assumes that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT.
- * If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot.
- * 
- * <p>Thus it DEPENDS on StateTypes.LOAD_AT_DEPOT
- *  
- * @author stefan
- *
- */
-class UpdateMaxLoad_ implements ActivityVisitor, StateUpdater {
-	private StateManager stateManager;
-	private int currentLoad = 0;
-	private VehicleRoute route;
-	private int maxLoad = 0;
-	
-	/**
-	 * Updates load at activity level. 
-	 * 
-	 * <p>Note that this assumes that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT.
-	 * If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot.
-	 *
-	 * <p>Thus it DEPENDS on StateTypes.LOAD_AT_DEPOT
-	 * 
-	 * 
-	 * 
-	 * <p>The loads can be retrieved by <br>
-	 * <code>stateManager.getActivityState(activity,StateTypes.LOAD);</code>
-	 * 
-	 * 
-	 * @author stefan
-	 *
-	 */
-	public UpdateMaxLoad_(StateManager stateManager) {
-		super();
-		this.stateManager = stateManager;
-	}
-	
-	@Override
-	public void begin(VehicleRoute route) {
-		currentLoad = (int) stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble();
-		maxLoad = currentLoad;
-		this.route = route;
-	}
-
-	@Override
-	public void visit(TourActivity act) {
-		currentLoad += act.getCapacityDemand();
-		maxLoad = Math.max(maxLoad, currentLoad);
-		assert currentLoad <= route.getVehicle().getCapacity() : "currentLoad at activity must not be > vehicleCapacity";
-		assert currentLoad >= 0 : "currentLoad at act must not be < 0";
-	}
-
-	@Override
-	public void finish() {
-		stateManager.putInternalRouteState(route, StateFactory.MAXLOAD, StateFactory.createState(maxLoad));
-		currentLoad = 0;
-		maxLoad = 0;
-	}
-}

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdatePrevMaxLoad.java

@@ -1,37 +0,0 @@
-package jsprit.core.algorithm.state;
-
-import jsprit.core.problem.solution.route.VehicleRoute;
-import jsprit.core.problem.solution.route.activity.ActivityVisitor;
-import jsprit.core.problem.solution.route.activity.TourActivity;
-import jsprit.core.problem.solution.route.state.StateFactory;
-
-
-class UpdatePrevMaxLoad implements ActivityVisitor, StateUpdater {
-	private StateManager stateManager;
-	private VehicleRoute route;
-	private double currLoad;
-	private double prevMaxLoad;
-	
-	public UpdatePrevMaxLoad(StateManager stateManager) {
-		super();
-		this.stateManager = stateManager;
-	}
-
-	@Override
-	public void begin(VehicleRoute route) {
-		this.route = route; 
-		currLoad = stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble();
-		prevMaxLoad = currLoad;
-	}
-
-	@Override
-	public void visit(TourActivity act) {
-		prevMaxLoad = Math.max(prevMaxLoad, stateManager.getActivityState(act, StateFactory.LOAD).toDouble());
-		stateManager.putInternalActivityState(act, StateFactory.PAST_MAXLOAD, StateFactory.createState(prevMaxLoad));
-		assert prevMaxLoad >= 0 : "maxLoad can never be smaller than 0";
-		assert prevMaxLoad <= route.getVehicle().getCapacity() : "maxLoad can never be bigger than vehicleCap";
-	}
-
-	@Override
-	public void finish() {}
-}

jsprit-core/src/main/java/jsprit/core/problem/solution/route/activity/DeliverService.java

@@ -23,7 +23,7 @@ public final class DeliverService implements DeliveryActivity{
 		this.delivery=deliveryActivity.getJob();
 		this.arrTime=deliveryActivity.getArrTime();
 		this.endTime=deliveryActivity.getEndTime();
-		capacity = deliveryActivity.getCapacity();
+		capacity = deliveryActivity.getSize();
 	}
 
 	/**
@@ -96,7 +96,7 @@ public final class DeliverService implements DeliveryActivity{
 	}
 
 	@Override
-	public Capacity getCapacity() {
+	public Capacity getSize() {
 		return capacity;
 	}
 }

jsprit-core/src/main/java/jsprit/core/problem/solution/route/activity/DeliverShipment.java

@@ -24,7 +24,7 @@ public final class DeliverShipment implements DeliveryActivity{
 		this.shipment = (Shipment) deliveryShipmentActivity.getJob();
 		this.arrTime = deliveryShipmentActivity.getArrTime();
 		this.endTime = deliveryShipmentActivity.getEndTime();
-		this.capacity = deliveryShipmentActivity.getCapacity();
+		this.capacity = deliveryShipmentActivity.getSize();
 	}
 
 	@Override
@@ -97,7 +97,7 @@ public final class DeliverShipment implements DeliveryActivity{
 	}
 
 	@Override
-	public Capacity getCapacity() {
+	public Capacity getSize() {
 		return capacity;
 	}
 }

jsprit-core/src/main/java/jsprit/core/problem/solution/route/activity/End.java

@@ -151,7 +151,7 @@ public final class End implements TourActivity {
 	}
 
 	@Override
-	public Capacity getCapacity() {
+	public Capacity getSize() {
 		return capacity;
 	}
 

jsprit-core/src/main/java/jsprit/core/problem/solution/route/activity/PickupService.java

@@ -98,7 +98,7 @@ public final class PickupService implements PickupActivity{
 	}
 
 	@Override
-	public Capacity getCapacity() {
+	public Capacity getSize() {
 		return pickup.getSize();
 	}
 

jsprit-core/src/main/java/jsprit/core/problem/solution/route/activity/PickupShipment.java

@@ -93,7 +93,7 @@ public final class PickupShipment implements PickupActivity{
 	}
 
 	@Override
-	public Capacity getCapacity() {
+	public Capacity getSize() {
 		return shipment.getSize();
 	}
 

jsprit-core/src/main/java/jsprit/core/problem/solution/route/activity/ServiceActivity.java

@@ -159,7 +159,7 @@ public class ServiceActivity implements JobActivity{
 	}
 
 	@Override
-	public Capacity getCapacity() {
+	public Capacity getSize() {
 		return service.getSize();
 	}
 	

jsprit-core/src/main/java/jsprit/core/problem/solution/route/activity/Start.java

@@ -155,7 +155,7 @@ public final class Start implements TourActivity {
 	}
 
 	@Override
-	public Capacity getCapacity() {
+	public Capacity getSize() {
 		return capacity;
 	}
 

jsprit-core/src/main/java/jsprit/core/problem/solution/route/activity/TourActivity.java

@@ -133,7 +133,7 @@ public interface TourActivity {
 	 * 
 	 * @return capacity
 	 */
-	public abstract Capacity getCapacity();
+	public abstract Capacity getSize();
 	
 	/**
 	 * Makes a deep copy of this activity.

jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateCapacityUtilizationForwardLookingTest.java

@@ -0,0 +1,174 @@
+package jsprit.core.algorithm.state;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import jsprit.core.problem.Capacity;
+import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
+import jsprit.core.problem.driver.Driver;
+import jsprit.core.problem.job.Delivery;
+import jsprit.core.problem.job.Job;
+import jsprit.core.problem.job.Pickup;
+import jsprit.core.problem.solution.route.ReverseRouteActivityVisitor;
+import jsprit.core.problem.solution.route.RouteActivityVisitor;
+import jsprit.core.problem.solution.route.VehicleRoute;
+import jsprit.core.problem.solution.route.state.StateFactory;
+import jsprit.core.problem.vehicle.Vehicle;
+
+import org.junit.Test;
+
+public class UpdateCapacityUtilizationForwardLookingTest {
+	
+	@Test
+	public void whenVehicleRouteHasPickupAndDelivery_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
+		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
+		UpdateLoads updateLoad = new UpdateLoads(stateManager);
+		UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(stateManager);
+		
+		RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
+		routeActivityVisitor.addActivityVisitor(updateLoad);
+		
+		ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
+		revRouteActivityVisitor.addActivityVisitor(updateMaxLoad);
+		
+		Pickup pickup = mock(Pickup.class);
+		when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
+		
+		Delivery delivery = mock(Delivery.class);
+		when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
+		
+		VehicleRoute route = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class))
+				.addService(pickup).addService(delivery).build();
+		
+		updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
+		routeActivityVisitor.visit(route);
+		revRouteActivityVisitor.visit(route);
+		
+		assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0),0.1);
+		assertEquals(1,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0),0.1);
+	}
+	
+	@Test
+	public void whenVehicleRouteHasPickupAndDeliveryWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
+		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
+		UpdateLoads updateLoad = new UpdateLoads(stateManager);
+		UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(stateManager);
+		
+		RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
+		routeActivityVisitor.addActivityVisitor(updateLoad);
+		
+		ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
+		revRouteActivityVisitor.addActivityVisitor(updateMaxLoad);
+		
+		Pickup pickup = mock(Pickup.class);
+		when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
+				.addDimension(1, 5).build());
+		
+		Delivery delivery = mock(Delivery.class);
+		when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
+				.addDimension(1, 3).build());
+		
+		VehicleRoute route = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class))
+				.addService(pickup).addService(delivery).build();
+		
+		updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
+		routeActivityVisitor.visit(route);
+		revRouteActivityVisitor.visit(route);
+		
+		assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0),0.1);
+		assertEquals(8,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1),0.1);
+		assertEquals(1,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0),0.1);
+		assertEquals(5,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1),0.1);
+	}
+	
+	@Test
+	public void whenVehicleRouteHasPickupAndDeliveryAndPickupWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
+		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
+		UpdateLoads updateLoad = new UpdateLoads(stateManager);
+		UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(stateManager);
+		
+		RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
+		routeActivityVisitor.addActivityVisitor(updateLoad);
+		
+		ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
+		revRouteActivityVisitor.addActivityVisitor(updateMaxLoad);
+		
+		Pickup pickup = mock(Pickup.class);
+		when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
+				.addDimension(1, 5).build());
+		
+		Delivery delivery = mock(Delivery.class);
+		when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
+				.addDimension(1, 3).build());
+		
+		Pickup pickup2 = mock(Pickup.class);
+		when(pickup2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3)
+				.addDimension(1, 8).build());
+		
+		VehicleRoute route = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class))
+				.addService(pickup).addService(delivery).addService(pickup2).build();
+		
+		updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
+		routeActivityVisitor.visit(route);
+		revRouteActivityVisitor.visit(route);
+		
+		assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
+		assertEquals(13,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
+		
+		assertEquals(4,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
+		assertEquals(13,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
+		
+		assertEquals(4,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
+		assertEquals(13,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
+		
+	}
+	
+	@Test
+	public void whenVehicleRouteHasPickupAndDeliveryAndPickupWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly_v2(){
+		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
+		UpdateLoads updateLoad = new UpdateLoads(stateManager);
+		UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(stateManager);
+		
+		RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
+		routeActivityVisitor.addActivityVisitor(updateLoad);
+		
+		ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
+		revRouteActivityVisitor.addActivityVisitor(updateMaxLoad);
+		
+		Pickup pickup = mock(Pickup.class);
+		when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
+				.addDimension(1, 5).build());
+		
+		Delivery delivery = mock(Delivery.class);
+		when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
+				.addDimension(1, 3).build());
+		
+		Pickup pickup2 = mock(Pickup.class);
+		when(pickup2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3)
+				.addDimension(1, 8).addDimension(4, 29).build());
+		
+		VehicleRoute route = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class))
+				.addService(pickup).addService(delivery).addService(pickup2).build();
+		
+		updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
+		routeActivityVisitor.visit(route);
+		revRouteActivityVisitor.visit(route);
+		
+		assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
+		assertEquals(13,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
+		assertEquals(29,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(4));
+		
+		assertEquals(4,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
+		assertEquals(13,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
+		assertEquals(29,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(4));
+		
+		assertEquals(4,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
+		assertEquals(13,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
+		
+		
+	}
+}

jsprit-core/src/test/java/jsprit/core/problem/solution/route/activity/DeliverServiceTest.java

@@ -23,9 +23,9 @@ public class DeliverServiceTest {
 	
 	@Test
 	public void whenCallingCapacity_itShouldReturnCorrectCapacity(){
-		assertEquals(-10,deliver.getCapacity().get(0));
+		assertEquals(-10,deliver.getSize().get(0));
-		assertEquals(-100,deliver.getCapacity().get(1));
+		assertEquals(-100,deliver.getSize().get(1));
-		assertEquals(-1000,deliver.getCapacity().get(2));
+		assertEquals(-1000,deliver.getSize().get(2));
 	}
 
 	@SuppressWarnings("deprecation")
@@ -67,9 +67,9 @@ public class DeliverServiceTest {
 		assertEquals(1.,copy.getTheoreticalEarliestOperationStartTime(),0.01);
 		assertEquals(2.,copy.getTheoreticalLatestOperationStartTime(),0.01);
 		assertEquals("loc",copy.getLocationId());
-		assertEquals(-10,copy.getCapacity().get(0));
+		assertEquals(-10,copy.getSize().get(0));
-		assertEquals(-100,copy.getCapacity().get(1));
+		assertEquals(-100,copy.getSize().get(1));
-		assertEquals(-1000,copy.getCapacity().get(2));
+		assertEquals(-1000,copy.getSize().get(2));
 		assertTrue(copy!=deliver);
 	}
 

jsprit-core/src/test/java/jsprit/core/problem/solution/route/activity/DeliverShipmentTest.java

@@ -25,9 +25,9 @@ public class DeliverShipmentTest {
 	
 	@Test
 	public void whenCallingCapacity_itShouldReturnCorrectCapacity(){
-		assertEquals(-10,deliver.getCapacity().get(0));
+		assertEquals(-10,deliver.getSize().get(0));
-		assertEquals(-100,deliver.getCapacity().get(1));
+		assertEquals(-100,deliver.getSize().get(1));
-		assertEquals(-1000,deliver.getCapacity().get(2));
+		assertEquals(-1000,deliver.getSize().get(2));
 	}
 
 	@SuppressWarnings("deprecation")
@@ -69,9 +69,9 @@ public class DeliverShipmentTest {
 		assertEquals(3.,copy.getTheoreticalEarliestOperationStartTime(),0.01);
 		assertEquals(4.,copy.getTheoreticalLatestOperationStartTime(),0.01);
 		assertEquals("deliveryLoc",copy.getLocationId());
-		assertEquals(-10,copy.getCapacity().get(0));
+		assertEquals(-10,copy.getSize().get(0));
-		assertEquals(-100,copy.getCapacity().get(1));
+		assertEquals(-100,copy.getSize().get(1));
-		assertEquals(-1000,copy.getCapacity().get(2));
+		assertEquals(-1000,copy.getSize().get(2));
 		assertTrue(copy!=deliver);
 	}
 
@@ -81,8 +81,8 @@ public class DeliverShipmentTest {
 		Shipment shipment = Shipment.Builder.newInstance("s").setPickupLocation("pickLoc").setDeliveryLocation("delLoc")
 				.addSizeDimension(0, 10).addSizeDimension(1, 100).build();
 		PickupShipment pick = new PickupShipment(shipment);
-		assertEquals(10,pick.getCapacity().get(0));
+		assertEquals(10,pick.getSize().get(0));
-		assertEquals(100,pick.getCapacity().get(1));
+		assertEquals(100,pick.getSize().get(1));
 	}
 
 }

jsprit-core/src/test/java/jsprit/core/problem/solution/route/activity/EndTest.java

@@ -10,7 +10,7 @@ public class EndTest {
 	@Test
 	public void whenCallingCapacity_itShouldReturnEmptyCapacity(){
 		End end = End.newInstance("loc", 0., 0.);
-		assertEquals(0,end.getCapacity().get(0));
+		assertEquals(0,end.getSize().get(0));
 	}
 
 	@Test

jsprit-core/src/test/java/jsprit/core/problem/solution/route/activity/PickupServiceTest.java

@@ -23,9 +23,9 @@ public class PickupServiceTest {
 	
 	@Test
 	public void whenCallingCapacity_itShouldReturnCorrectCapacity(){
-		assertEquals(10,pickup.getCapacity().get(0));
+		assertEquals(10,pickup.getSize().get(0));
-		assertEquals(100,pickup.getCapacity().get(1));
+		assertEquals(100,pickup.getSize().get(1));
-		assertEquals(1000,pickup.getCapacity().get(2));
+		assertEquals(1000,pickup.getSize().get(2));
 	}
 
 	@SuppressWarnings("deprecation")
@@ -67,9 +67,9 @@ public class PickupServiceTest {
 		assertEquals(1.,copy.getTheoreticalEarliestOperationStartTime(),0.01);
 		assertEquals(2.,copy.getTheoreticalLatestOperationStartTime(),0.01);
 		assertEquals("loc",copy.getLocationId());
-		assertEquals(10,copy.getCapacity().get(0));
+		assertEquals(10,copy.getSize().get(0));
-		assertEquals(100,copy.getCapacity().get(1));
+		assertEquals(100,copy.getSize().get(1));
-		assertEquals(1000,copy.getCapacity().get(2));
+		assertEquals(1000,copy.getSize().get(2));
 		assertTrue(copy!=pickup);
 	}
 

jsprit-core/src/test/java/jsprit/core/problem/solution/route/activity/PickupShipmentTest.java

@@ -25,9 +25,9 @@ public class PickupShipmentTest {
 	
 	@Test
 	public void whenCallingCapacity_itShouldReturnCorrectCapacity(){
-		assertEquals(10,pickup.getCapacity().get(0));
+		assertEquals(10,pickup.getSize().get(0));
-		assertEquals(100,pickup.getCapacity().get(1));
+		assertEquals(100,pickup.getSize().get(1));
-		assertEquals(1000,pickup.getCapacity().get(2));
+		assertEquals(1000,pickup.getSize().get(2));
 	}
 
 	@SuppressWarnings("deprecation")
@@ -69,9 +69,9 @@ public class PickupShipmentTest {
 		assertEquals(1.,copy.getTheoreticalEarliestOperationStartTime(),0.01);
 		assertEquals(2.,copy.getTheoreticalLatestOperationStartTime(),0.01);
 		assertEquals("pickupLoc",copy.getLocationId());
-		assertEquals(10,copy.getCapacity().get(0));
+		assertEquals(10,copy.getSize().get(0));
-		assertEquals(100,copy.getCapacity().get(1));
+		assertEquals(100,copy.getSize().get(1));
-		assertEquals(1000,copy.getCapacity().get(2));
+		assertEquals(1000,copy.getSize().get(2));
 		assertTrue(copy!=pickup);
 	}
 
@@ -81,8 +81,8 @@ public class PickupShipmentTest {
 		Shipment shipment = Shipment.Builder.newInstance("s").setPickupLocation("pickLoc").setDeliveryLocation("delLoc")
 				.addSizeDimension(0, 10).addSizeDimension(1, 100).build();
 		PickupShipment pick = new PickupShipment(shipment);
-		assertEquals(10,pick.getCapacity().get(0));
+		assertEquals(10,pick.getSize().get(0));
-		assertEquals(100,pick.getCapacity().get(1));
+		assertEquals(100,pick.getSize().get(1));
 	}
 		
 }

jsprit-core/src/test/java/jsprit/core/problem/solution/route/activity/ServiceActivityTest.java

@@ -42,9 +42,9 @@ public class ServiceActivityTest {
 	
 	@Test
 	public void whenCallingCapacity_itShouldReturnCorrectCapacity(){
-		assertEquals(10,serviceActivity.getCapacity().get(0));
+		assertEquals(10,serviceActivity.getSize().get(0));
-		assertEquals(100,serviceActivity.getCapacity().get(1));
+		assertEquals(100,serviceActivity.getSize().get(1));
-		assertEquals(1000,serviceActivity.getCapacity().get(2));
+		assertEquals(1000,serviceActivity.getSize().get(2));
 	}
 
 	

jsprit-core/src/test/java/jsprit/core/problem/solution/route/activity/StartTest.java

@@ -9,7 +9,7 @@ public class StartTest {
 	@Test
 	public void whenCallingCapacity_itShouldReturnEmptyCapacity(){
 		Start start = Start.newInstance("loc", 0., 0.);
-		assertEquals(0,start.getCapacity().get(0));
+		assertEquals(0,start.getSize().get(0));
 	}
 
 	@Test