test vrp with shipments and services

jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java

@@ -23,25 +23,16 @@ import org.junit.Before;
 import org.junit.Test;
 
 import util.Solutions;
-import algorithms.ConstraintManager.Priority;
-import algorithms.StateManager.StateImpl;
 import algorithms.acceptors.AcceptNewIfBetterThanWorst;
 import algorithms.selectors.SelectBest;
-import basics.Delivery;
-import basics.Job;
-import basics.Pickup;
 import basics.VehicleRoutingAlgorithm;
 import basics.VehicleRoutingProblem;
 import basics.VehicleRoutingProblemSolution;
-import basics.algo.InsertionStartsListener;
-import basics.algo.JobInsertedListener;
 import basics.algo.SearchStrategy;
 import basics.algo.SearchStrategyManager;
 import basics.algo.SolutionCostCalculator;
 import basics.io.VrpXMLReader;
 import basics.route.InfiniteFleetManagerFactory;
-import basics.route.ReverseRouteActivityVisitor;
-import basics.route.RouteActivityVisitor;
 import basics.route.VehicleFleetManager;
 import basics.route.VehicleRoute;
 
@@ -62,21 +53,15 @@ public class BuildPDVRPAlgoFromScratchTest {
 			
 			final StateManager stateManager = new StateManager();
 			
-			ConstraintManager actLevelConstraintAccumulator = new ConstraintManager(vrp,stateManager);
+			ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
-			actLevelConstraintAccumulator.addConstraint(new ServiceLoadActivityLevelConstraint(stateManager),Priority.LOW);
+			constraintManager.addTimeWindowConstraint();
-			actLevelConstraintAccumulator.addConstraint(new TimeWindowConstraint(stateManager, vrp.getTransportCosts()),Priority.HIGH);
+			constraintManager.addLoadConstraint();
-			
-			ActivityInsertionCostsCalculator marginalCalculus = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts());
-
-
-			ServiceInsertionCalculator serviceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), marginalCalculus, new ServiceLoadRouteLevelConstraint(stateManager), actLevelConstraintAccumulator);
-
-//			CalculatesServiceInsertion serviceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), marginalCalculus, new HardConstraints.HardLoadConstraint(stateManager));
 			
 			VehicleFleetManager fleetManager = new InfiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
-			JobInsertionCostsCalculator finalServiceInsertion = new VehicleTypeDependentJobInsertionCalculator(fleetManager, serviceInsertion);
 			
-			BestInsertion bestInsertion = new BestInsertion(finalServiceInsertion);
+			BestInsertionBuilder iBuilder = new BestInsertionBuilder(vrp, fleetManager, stateManager, constraintManager);
+//			iBuilder.setConstraintManager(constraintManger);
+			InsertionStrategy bestInsertion = iBuilder.build();
 				
 			RuinRadial radial = new RuinRadial(vrp, 0.15, new JobDistanceAvgCosts(vrp.getTransportCosts()));
 			RuinRandom random = new RuinRandom(vrp, 0.25);
@@ -105,80 +90,14 @@ public class BuildPDVRPAlgoFromScratchTest {
 			strategyManager.addStrategy(radialStrategy, 0.5);
 			strategyManager.addStrategy(randomStrategy, 0.5);
 			
-			vra = new VehicleRoutingAlgorithm(vrp, strategyManager);
+			vra = new VehicleRoutingAlgorithmFactoryImpl(strategyManager, stateManager, fleetManager).createAlgorithm(vrp);
-	
-			vra.getAlgorithmListeners().addListener(stateManager);
-			
-			final RouteActivityVisitor iterateForward = new RouteActivityVisitor();
-			
-			iterateForward.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
-//			iterateForward.addActivityVisitor(new UpdateEarliestStartTime(stateManager, vrp.getTransportCosts()));
-			iterateForward.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
-			
-			iterateForward.addActivityVisitor(new UpdateOccuredDeliveries(stateManager));
-			iterateForward.addActivityVisitor(new UpdateLoads(stateManager));
-			
-			final ReverseRouteActivityVisitor iterateBackward = new ReverseRouteActivityVisitor();
-			iterateBackward.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts()));
-			iterateBackward.addActivityVisitor(new UpdateFuturePickups(stateManager));
-			
-			
-			InsertionStartsListener loadVehicleInDepot = new InsertionStartsListener() {
-				
-				@Override
-				public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
-					for(VehicleRoute route : vehicleRoutes){
-						int loadAtDepot = 0;
-						int loadAtEnd = 0;
-						for(Job j : route.getTourActivities().getJobs()){
-							if(j instanceof Delivery){
-								loadAtDepot += j.getCapacityDemand();
-							}
-							if(j instanceof Pickup){
-								loadAtEnd += j.getCapacityDemand();
-							}
-						}
-						stateManager.putRouteState(route, StateFactory.LOAD_AT_BEGINNING, new StateImpl(loadAtDepot));
-						stateManager.putRouteState(route, StateFactory.LOAD, new StateImpl(loadAtEnd));
-						iterateForward.visit(route);
-						iterateBackward.visit(route);
-					}
-				}
-				
-			};
-			
-			vra.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager));
-			
-			JobInsertedListener updateLoadAfterJobHasBeenInserted = new JobInsertedListener() {
-				
-				@Override
-				public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
-//					log.info("insert job " + job2insert.getClass().toString() + " job " + job2insert + "" + job2insert.getCapacityDemand() + " in route " + inRoute.getTourActivities());
-					
-					if(job2insert instanceof Delivery){
-						int loadAtDepot = (int) stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING).toDouble();
-//						log.info("loadAtDepot="+loadAtDepot);
-						stateManager.putRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING, StateFactory.createState(loadAtDepot + job2insert.getCapacityDemand()));
-					}
-					if(job2insert instanceof Pickup){
-						int loadAtEnd = (int) stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_END).toDouble();
-//						log.info("loadAtEnd="+loadAtEnd);
-						stateManager.putRouteState(inRoute, StateFactory.LOAD_AT_END, StateFactory.createState(loadAtEnd + job2insert.getCapacityDemand()));
-					}
-					iterateForward.visit(inRoute);
-					iterateBackward.visit(inRoute);
-				}
-			};
-						
-			bestInsertion.addListener(loadVehicleInDepot);
-			bestInsertion.addListener(updateLoadAfterJobHasBeenInserted);
 			
 			VehicleRoutingProblemSolution iniSolution = new InsertionInitialSolutionFactory(bestInsertion, solutionCostCalculator).createSolution(vrp);
 
 //			System.out.println("ini: costs="+iniSolution.getCost()+";#routes="+iniSolution.getRoutes().size());
 			vra.addInitialSolution(iniSolution);
-			vra.setNuOfIterations(10000);
+			vra.setNuOfIterations(1000);
-			vra.setPrematureBreak(1000);
+			vra.setPrematureBreak(100);
 			
 	}
 	

jsprit-core/src/test/java/algorithms/BuildPDVRPWithShipmentsAlgoFromScratchTest.java

@@ -137,12 +137,12 @@ public class BuildPDVRPWithShipmentsAlgoFromScratchTest {
 			iterateForward.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
 			iterateForward.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
 			
-			iterateForward.addActivityVisitor(new UpdateOccuredDeliveries(stateManager));
+			iterateForward.addActivityVisitor(new UpdatePrevMaxLoad(stateManager));
 			iterateForward.addActivityVisitor(new UpdateLoads(stateManager));
 			
 			final ReverseRouteActivityVisitor iterateBackward = new ReverseRouteActivityVisitor();
 			iterateBackward.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts()));
-			iterateBackward.addActivityVisitor(new UpdateFuturePickups(stateManager));
+			iterateBackward.addActivityVisitor(new UpdateMaxLoad(stateManager));
 			
 			JobInsertedListener updateWhenJobHasBeenInserted = new JobInsertedListener() {
 				

jsprit-core/src/test/java/algorithms/ServiceInsertionAndLoadConstraintsTest.java

@@ -0,0 +1,139 @@
+package algorithms;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import java.util.Arrays;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import util.Coordinate;
+import util.Locations;
+import util.ManhattanCosts;
+import algorithms.ConstraintManager.Priority;
+import basics.Delivery;
+import basics.Pickup;
+import basics.Service;
+import basics.Shipment;
+import basics.VehicleRoutingProblem;
+import basics.costs.VehicleRoutingActivityCosts;
+import basics.costs.VehicleRoutingTransportCosts;
+import basics.route.Driver;
+import basics.route.DriverImpl;
+import basics.route.RouteActivityVisitor;
+import basics.route.TourActivity;
+import basics.route.Vehicle;
+import basics.route.VehicleImpl;
+import basics.route.VehicleRoute;
+import basics.route.VehicleType;
+import basics.route.VehicleTypeImpl;
+
+public class ServiceInsertionAndLoadConstraintsTest {
+	
+	VehicleRoutingTransportCosts routingCosts;
+	
+	VehicleRoutingActivityCosts activityCosts = new VehicleRoutingActivityCosts(){
+
+		@Override
+		public double getActivityCost(TourActivity tourAct, double arrivalTime,Driver driver, Vehicle vehicle) {
+			return 0;
+		}
+		
+	};
+	
+	HardActivityStateLevelConstraint hardActivityLevelConstraint = new HardActivityStateLevelConstraint() {
+		
+		@Override
+		public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct,TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
+			return ConstraintsStatus.FULFILLED;
+		}
+	};
+	
+	HardRouteStateLevelConstraint hardRouteLevelConstraint = new HardRouteStateLevelConstraint(){
+
+		@Override
+		public boolean fulfilled(InsertionContext insertionContext) {
+			return true;
+		}
+		
+	};
+	
+	ActivityInsertionCostsCalculator activityInsertionCostsCalculator;
+	
+	ShipmentInsertionCalculator insertionCalculator;
+	
+	Vehicle vehicle;
+	
+	@Before
+	public void doBefore(){
+		Locations locations = new Locations(){
+
+			@Override
+			public Coordinate getCoord(String id) {
+				//assume: locationId="x,y"
+				String[] splitted = id.split(",");
+				return Coordinate.newInstance(Double.parseDouble(splitted[0]), 
+						Double.parseDouble(splitted[1]));
+			}
+			
+		};
+		routingCosts = new ManhattanCosts(locations);
+		VehicleType type = VehicleTypeImpl.Builder.newInstance("t", 2).setCostPerDistance(1).build();
+		vehicle = VehicleImpl.Builder.newInstance("v").setLocationId("0,0").setType(type).build();
+		activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts);
+		createInsertionCalculator(hardRouteLevelConstraint);
+	}
+
+	private void createInsertionCalculator(HardRouteStateLevelConstraint hardRouteLevelConstraint) {
+		insertionCalculator = new ShipmentInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, hardActivityLevelConstraint);
+	}
+	
+	@Test
+	public void whenInsertingServiceWhileNoCapIsAvailable_itMustReturnTheCorrectInsertionIndex(){
+		Delivery delivery = (Delivery) Delivery.Builder.newInstance("del", 41).setLocationId("10,10").build();
+		Pickup pickup = (Pickup) Pickup.Builder.newInstance("pick", 15).setLocationId("0,10").build();
+		
+		VehicleType type = VehicleTypeImpl.Builder.newInstance("t", 50).setCostPerDistance(1).build();
+		Vehicle vehicle = VehicleImpl.Builder.newInstance("v").setLocationId("0,0").setType(type).build();
+		
+		VehicleRoute route = VehicleRoute.emptyRoute();
+		route.setVehicle(vehicle, 0.0);
+		
+		Inserter inserter = new Inserter(new InsertionListeners());
+		
+		inserter.insertJob(delivery, new InsertionData(0,0,0,vehicle,null), route);
+//		inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
+//		inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
+		
+		StateManager stateManager = new StateManager();
+		
+//		RouteActivityVisitor routeActVisitor = new RouteActivityVisitor();
+//		routeActVisitor.addActivityVisitor(new UpdateLoads(stateManager));
+//		routeActVisitor.visit(route);
+		
+		VehicleRoutingProblem vrp = mock(VehicleRoutingProblem.class);
+		
+		ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
+		constraintManager.addLoadConstraint();
+//		constraintManager.addConstraint(new PickupAndDeliverShipmentLoadActivityLevelConstraint(stateManager),Priority.CRITICAL);
+//		constraintManager.addConstraint(new ShipmentPickupsFirstConstraint(),Priority.CRITICAL);
+		
+		stateManager.informInsertionStarts(Arrays.asList(route), null);
+		
+		JobCalculatorSwitcher switcher = new JobCalculatorSwitcher();
+		ServiceInsertionCalculator serviceInsertionCalc = new ServiceInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, constraintManager);
+		ShipmentInsertionCalculator insertionCalculator = new ShipmentInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, constraintManager);
+		switcher.put(Pickup.class, serviceInsertionCalc);
+		switcher.put(Delivery.class, serviceInsertionCalc);
+		switcher.put(Shipment.class, insertionCalculator);
+		
+//		Pickup service = (Pickup)Pickup.Builder.newInstance("pick", 1).setLocationId("5,5").build();
+		InsertionData iData = switcher.getInsertionData(route, pickup, vehicle, 0, DriverImpl.noDriver(), Double.MAX_VALUE);
+//		routeActVisitor.visit(route);
+		
+		assertEquals(1, iData.getDeliveryInsertionIndex());
+	}
+	
+}

jsprit-core/src/test/java/algorithms/ShipmentInsertionCalculatorTest.java

@@ -2,9 +2,9 @@ package algorithms;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+
+import java.util.Arrays;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -13,7 +13,9 @@ import util.Coordinate;
 import util.Locations;
 import util.ManhattanCosts;
 import algorithms.ConstraintManager.Priority;
-import algorithms.HardActivityStateLevelConstraint.ConstraintsStatus;
+import basics.Delivery;
+import basics.Pickup;
+import basics.Service;
 import basics.Shipment;
 import basics.VehicleRoutingProblem;
 import basics.costs.VehicleRoutingActivityCosts;
@@ -201,4 +203,48 @@ public class ShipmentInsertionCalculatorTest {
 		
 	}
 	
+	@Test
+	public void whenInsertingServiceWhileNoCapIsAvailable_itMustReturnNoInsertionData(){
+		Shipment shipment = Shipment.Builder.newInstance("s", 1).setPickupLocation("0,10").setDeliveryLocation("0,0").build();
+		Shipment shipment2 = Shipment.Builder.newInstance("s2", 1).setPickupLocation("10,10").setDeliveryLocation("0,0").build();
+		Shipment shipment3 = Shipment.Builder.newInstance("s3", 1).setPickupLocation("10,10").setDeliveryLocation("0,").build();
+		
+		VehicleRoute route = VehicleRoute.emptyRoute();
+		route.setVehicle(vehicle, 0.0);
+		
+		Inserter inserter = new Inserter(new InsertionListeners());
+		
+		inserter.insertJob(shipment, new InsertionData(0,0,0,vehicle,null), route);
+		inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
+//		inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
+		
+		StateManager stateManager = new StateManager();
+		
+//		RouteActivityVisitor routeActVisitor = new RouteActivityVisitor();
+//		routeActVisitor.addActivityVisitor(new UpdateLoads(stateManager));
+//		routeActVisitor.visit(route);
+		
+		VehicleRoutingProblem vrp = mock(VehicleRoutingProblem.class);
+		
+		ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
+		constraintManager.addLoadConstraint();
+//		constraintManager.addConstraint(new PickupAndDeliverShipmentLoadActivityLevelConstraint(stateManager),Priority.CRITICAL);
+//		constraintManager.addConstraint(new ShipmentPickupsFirstConstraint(),Priority.CRITICAL);
+		
+		stateManager.informInsertionStarts(Arrays.asList(route), null);
+		
+		JobCalculatorSwitcher switcher = new JobCalculatorSwitcher();
+		ServiceInsertionCalculator serviceInsertionCalc = new ServiceInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, constraintManager);
+		ShipmentInsertionCalculator insertionCalculator = new ShipmentInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, constraintManager);
+		switcher.put(Pickup.class, serviceInsertionCalc);
+		switcher.put(Shipment.class, insertionCalculator);
+		
+		Pickup service = (Pickup)Pickup.Builder.newInstance("pick", 1).setLocationId("5,5").build();
+		InsertionData iData = switcher.getInsertionData(route, service, vehicle, 0, DriverImpl.noDriver(), Double.MAX_VALUE);
+//		routeActVisitor.visit(route);
+		
+		assertEquals(3, iData.getDeliveryInsertionIndex());
+	}
+	
+	
 }