diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateActivityTimes.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateActivityTimes.java index 2264aaa0..868532f8 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateActivityTimes.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateActivityTimes.java @@ -33,8 +33,6 @@ import jsprit.core.util.ActivityTimeTracker; */ public class UpdateActivityTimes implements ActivityVisitor, StateUpdater{ - - private ActivityTimeTracker timeTracker; private VehicleRoute route; diff --git a/jsprit-core/src/main/java/jsprit/core/analysis/SolutionAnalyser.java b/jsprit-core/src/main/java/jsprit/core/analysis/SolutionAnalyser.java new file mode 100644 index 00000000..7eb9449c --- /dev/null +++ b/jsprit-core/src/main/java/jsprit/core/analysis/SolutionAnalyser.java @@ -0,0 +1,368 @@ +/******************************************************************************* + * Copyright (C) 2014 Stefan Schroeder + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see . + ******************************************************************************/ + +package jsprit.core.analysis; + +import jsprit.core.algorithm.state.InternalStates; +import jsprit.core.algorithm.state.StateId; +import jsprit.core.algorithm.state.StateManager; +import jsprit.core.algorithm.state.StateUpdater; +import jsprit.core.problem.Capacity; +import jsprit.core.problem.VehicleRoutingProblem; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.ActivityVisitor; +import jsprit.core.problem.solution.route.activity.End; +import jsprit.core.problem.solution.route.activity.Start; +import jsprit.core.problem.solution.route.activity.TourActivity; +import jsprit.core.util.ActivityTimeTracker; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +/** + * + */ +public class SolutionAnalyser { + + public static interface DistanceCalculator { + + public double getDistance(String fromLocationId, String toLocationId); + + } + + private static class SumUpWaitingTimes implements StateUpdater, ActivityVisitor { + + private StateId waiting_time_id; + + private StateId transport_time_id; + + private StateId service_time_id; + + private StateManager stateManager; + + private ActivityTimeTracker.ActivityPolicy activityPolicy; + + private VehicleRoute route; + + double sum_waiting_time = 0.; + + double sum_transport_time = 0.; + + double sum_service_time = 0.; + + double prevActDeparture; + + private SumUpWaitingTimes(StateId waiting_time_id, StateId transport_time_id, StateId service_time_id, StateManager stateManager, ActivityTimeTracker.ActivityPolicy activityPolicy) { + this.waiting_time_id = waiting_time_id; + this.transport_time_id = transport_time_id; + this.service_time_id = service_time_id; + this.stateManager = stateManager; + this.activityPolicy = activityPolicy; + } + + @Override + public void begin(VehicleRoute route) { + this.route = route; + sum_waiting_time = 0.; + sum_transport_time = 0.; + sum_service_time = 0.; + prevActDeparture = route.getDepartureTime(); + } + + @Override + public void visit(TourActivity activity) { + //waiting time + double waitAtAct = 0.; + if(activityPolicy.equals(ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS)){ + waitAtAct = Math.max(0,activity.getTheoreticalEarliestOperationStartTime() - activity.getArrTime()); + } + sum_waiting_time += waitAtAct; + //transport time + double transportTime = activity.getArrTime() - prevActDeparture; + sum_transport_time += transportTime; + prevActDeparture = activity.getEndTime(); + //service time + sum_service_time += activity.getOperationTime(); + } + + @Override + public void finish() { + sum_transport_time += route.getEnd().getArrTime() - prevActDeparture; + stateManager.putRouteState(route,transport_time_id,sum_transport_time); + stateManager.putRouteState(route,waiting_time_id,sum_waiting_time); + stateManager.putRouteState(route,service_time_id,sum_service_time); + } + } + + private static class DistanceUpdater implements StateUpdater, ActivityVisitor { + + private StateId distance_id; + + private StateManager stateManager; + + private double sum_distance = 0.; + + private DistanceCalculator distanceCalculator; + + private TourActivity prevAct; + + private VehicleRoute route; + + private DistanceUpdater(StateId distance_id, StateManager stateManager, DistanceCalculator distanceCalculator) { + this.distance_id = distance_id; + this.stateManager = stateManager; + this.distanceCalculator = distanceCalculator; + } + + @Override + public void begin(VehicleRoute route) { + sum_distance = 0.; + this.route = route; + this.prevAct = route.getStart(); + } + + @Override + public void visit(TourActivity activity) { + double distance = distanceCalculator.getDistance(prevAct.getLocationId(),activity.getLocationId()); + sum_distance += distance; + stateManager.putActivityState(activity,distance_id,sum_distance); + prevAct = activity; + } + + @Override + public void finish() { + double distance = distanceCalculator.getDistance(prevAct.getLocationId(), route.getEnd().getLocationId()); + sum_distance += distance; + stateManager.putRouteState(route,distance_id,sum_distance); + } + } + + private VehicleRoutingProblem vrp; + + private List routes; + + private StateManager stateManager; + + private DistanceCalculator distanceCalculator; + + private final StateId waiting_time_id; + + private final StateId transport_time_id; + + private final StateId service_time_id; + + private final StateId distance_id; + + private ActivityTimeTracker.ActivityPolicy activityPolicy; + + public SolutionAnalyser(VehicleRoutingProblem vrp, Collection routes, StateManager stateManager, DistanceCalculator distanceCalculator) { + this.vrp = vrp; + this.routes = new ArrayList(routes); + this.stateManager = stateManager; + this.distanceCalculator = distanceCalculator; + waiting_time_id = stateManager.createStateId("waiting-time"); + transport_time_id = stateManager.createStateId("transport-time"); + service_time_id = stateManager.createStateId("service-time"); + distance_id = stateManager.createStateId("distance"); + activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_ARRIVED; + if(stateManager.timeWindowUpdateIsActivated()){ + activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS; + } + stateManager.addStateUpdater(new SumUpWaitingTimes(waiting_time_id, transport_time_id, service_time_id, stateManager, activityPolicy)); + stateManager.addStateUpdater(new DistanceUpdater(distance_id,stateManager,distanceCalculator)); + refreshStates(); + } + + private void refreshStates(){ + stateManager.clear(); + stateManager.informInsertionStarts(routes,null); + } +// +// +// public void informRouteChanged(VehicleRoute route){ +//// update(route); +// } +// +// + + /** + * @param route to get the load at beginning from + * @return load at start location of specified route + */ + public Capacity getLoadAtBeginning(VehicleRoute route){ + return stateManager.getRouteState(route, InternalStates.LOAD_AT_BEGINNING,Capacity.class); + } + + /** + * @param route to get the load at the end from + * @return load at end location of specified route + */ + public Capacity getLoadAtEnd(VehicleRoute route){ + return stateManager.getRouteState(route, InternalStates.LOAD_AT_END,Capacity.class); + } + + /** + * @param route to get max load from + * @return max load of specified route, i.e. for each capacity dimension the max value. + */ + public Capacity getMaxLoad(VehicleRoute route){ + return stateManager.getRouteState(route, InternalStates.MAXLOAD,Capacity.class); + } + + /** + * + * @param activity to get the load from (after activity) + * @return load right after the specified activity. If act is Start, it returns the load atBeginning of the specified + * route. If act is End, it returns the load atEnd of specified route. + * Returns null if no load can be found. + */ + public Capacity getLoadRightAfterActivity(TourActivity activity, VehicleRoute route){ + if(activity instanceof Start) return getLoadAtBeginning(route); + if(activity instanceof End) return getLoadAtEnd(route); + return stateManager.getActivityState(activity, InternalStates.LOAD,Capacity.class); + } + + /** + * @param activity to get the load from (before activity) + * @return load just before the specified activity. If act is Start, it returns the load atBeginning of the specified + * route. If act is End, it returns the load atEnd of specified route. + */ + public Capacity getLoadJustBeforeActivity(TourActivity activity, VehicleRoute route){ + if(activity instanceof Start) return getLoadAtBeginning(route); + if(activity instanceof End) return getLoadAtEnd(route); + Capacity afterAct = stateManager.getActivityState(activity, InternalStates.LOAD,Capacity.class); + if(afterAct != null && activity.getSize() != null){ + return Capacity.subtract(afterAct, activity.getSize()); + } + else if(afterAct != null) return afterAct; + else return null; + } +// +//// public Capacity getViolationAtBeginning(VehicleRoute route){ +//// Capacity atBeginning = getLoadAtBeginning(route); +//// return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(atBeginning,route.getVehicle().getType().getCapacityDimensions())); +//// } +//// +//// public Capacity getViolationAtEnd(VehicleRoute route){ +//// Capacity atEnd = getLoadAtEnd(route); +//// return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(atEnd,route.getVehicle().getType().getCapacityDimensions())); +//// } +//// +//// public Capacity getViolationRightAfterActivity(TourActivity activity, VehicleRoute route){ +//// Capacity afterAct = getLoadRightAfterActivity(activity); +//// return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(afterAct,route.getVehicle().getType().getCapacityDimensions())); +//// } + + /** + * @param route to get the total operation time from + * @return operation time of this route, i.e. endTime - startTime of specified route + */ + public Double getOperationTime(VehicleRoute route){ + return route.getEnd().getArrTime() - route.getStart().getEndTime(); + } + + /** + * @param route to get the total waiting time from + * @return total waiting time of this route, i.e. sum of waiting times at activities. + * Returns null if no waiting time value exists for the specified route + */ + public Double getWaitingTime(VehicleRoute route){ + return stateManager.getRouteState(route, waiting_time_id, Double.class); + } + + /** + * @param route to get the total transport time from + * @return total transport time of specified route. Returns null if no time value exists for the specified route. + */ + public Double getTransportTime(VehicleRoute route){ + return stateManager.getRouteState(route, transport_time_id, Double.class); + } + + /** + * @param route to get the total service time from + * @return total service time of specified route. Returns null if no time value exists for specified route. + */ + public Double getServiceTime(VehicleRoute route){ + return stateManager.getRouteState(route, service_time_id, Double.class); + } + + /** + * @param activity to get the waiting from + * @return waiting time at activity + */ + public Double getWaitingTimeAtActivity(TourActivity activity, VehicleRoute route){ + double waitingTime = 0.; + if(activityPolicy.equals(ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS)){ + waitingTime = Math.max(0,activity.getTheoreticalEarliestOperationStartTime()-activity.getArrTime()); + } + return waitingTime; + } +// +// public double getTimeTooLateAtActivity(TourActivity activity){ +// +// } +// + /** + * @param route to get the distance from + * @return total distance of route + */ + public Double getDistance(VehicleRoute route){ + return stateManager.getRouteState(route, distance_id, Double.class); + } + + /** + * @param activity at which is distance of the current route is measured + * @return distance at activity + */ + public double getDistanceAtActivity(TourActivity activity, VehicleRoute route){ + if(activity instanceof Start) return 0.; + if(activity instanceof End) return getDistance(route); + return stateManager.getActivityState(activity, distance_id, Double.class); + } + +// +// /** +// * @return total distance +// */ +// public double getDistance(){ +// +// } +// +// /** +// * @return total operation time +// */ +// public double getOperationTime(){ +// +// } +// +// /** +// * @return total waiting time +// */ +// public double getWaitingTime(){ +// +// } +// +// /** +// * @return total transportation time +// */ +// public double getTransportationTime(){ +// +// } + +} + diff --git a/jsprit-core/src/test/java/jsprit/core/analysis/SolutionAnalyserTest.java b/jsprit-core/src/test/java/jsprit/core/analysis/SolutionAnalyserTest.java new file mode 100644 index 00000000..89a806e2 --- /dev/null +++ b/jsprit-core/src/test/java/jsprit/core/analysis/SolutionAnalyserTest.java @@ -0,0 +1,547 @@ +/******************************************************************************* + * Copyright (C) 2014 Stefan Schroeder + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see . + ******************************************************************************/ + +package jsprit.core.analysis; + + +import jsprit.core.algorithm.VehicleRoutingAlgorithm; +import jsprit.core.algorithm.VehicleRoutingAlgorithmBuilder; +import jsprit.core.algorithm.state.StateManager; +import jsprit.core.problem.VehicleRoutingProblem; +import jsprit.core.problem.constraint.ConstraintManager; +import jsprit.core.problem.job.Service; +import jsprit.core.problem.job.Shipment; +import jsprit.core.problem.solution.VehicleRoutingProblemSolution; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.TimeWindow; +import jsprit.core.problem.vehicle.VehicleImpl; +import jsprit.core.problem.vehicle.VehicleType; +import jsprit.core.problem.vehicle.VehicleTypeImpl; +import jsprit.core.util.Coordinate; +import jsprit.core.util.ManhattanCosts; +import jsprit.core.util.Solutions; +import junit.framework.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.Iterator; + +import static org.junit.Assert.assertFalse; + +public class SolutionAnalyserTest { + + private VehicleRoutingProblem vrp; + + private VehicleRoutingProblemSolution solution; + + private StateManager stateManager; + + private SolutionAnalyser.DistanceCalculator distanceCalculator; + + @Before + public void doBefore(){ + + VehicleType type = VehicleTypeImpl.Builder.newInstance("type").addCapacityDimension(0,15).build(); + + VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v1").setType(type) + .setStartLocationCoordinate(Coordinate.newInstance(-5, 0)).build(); + + VehicleImpl vehicle2 = VehicleImpl.Builder.newInstance("v2").setType(type) + .setStartLocationCoordinate(Coordinate.newInstance(5, 0)).build(); + + Service s1 = Service.Builder.newInstance("s1") + .setTimeWindow(TimeWindow.newInstance(10, 20)) + .setCoord(Coordinate.newInstance(-10, 1)).addSizeDimension(0, 2).build(); + Service s2 = Service.Builder.newInstance("s2").setCoord(Coordinate.newInstance(-10, 10)).addSizeDimension(0,3).build(); + Shipment shipment1 = Shipment.Builder.newInstance("ship1").setPickupCoord(Coordinate.newInstance(-15, 2)) + .setDeliveryCoord(Coordinate.newInstance(-16, 5)).addSizeDimension(0,10) + .setPickupServiceTime(20.).setDeliveryServiceTime(20.).build(); + + Service s3 = Service.Builder.newInstance("s3") + .setTimeWindow(TimeWindow.newInstance(10, 20)) + .setCoord(Coordinate.newInstance(10, 1)).addSizeDimension(0,2).build(); + Service s4 = Service.Builder.newInstance("s4").setCoord(Coordinate.newInstance(10, 10)).addSizeDimension(0,3).build(); + Shipment shipment2 = Shipment.Builder.newInstance("ship2").setPickupCoord(Coordinate.newInstance(15, 2)) + .setPickupServiceTime(20.).setDeliveryServiceTime(20.) + .setDeliveryCoord(Coordinate.newInstance(16, 5)).addSizeDimension(0,10).build(); + + VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addVehicle(vehicle2).addJob(s1) + .addJob(s2).addJob(shipment1).addJob(s3).addJob(s4).addJob(shipment2).setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); + vrpBuilder.setRoutingCost(new ManhattanCosts(vrpBuilder.getLocations())); + vrp = vrpBuilder.build(); + + VehicleRoutingAlgorithmBuilder vraBuilder = new VehicleRoutingAlgorithmBuilder(vrp,"src/test/resources/algorithmConfig.xml"); + vraBuilder.addDefaultCostCalculators(); + vraBuilder.addCoreConstraints(); + stateManager = new StateManager(vrp); + ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); + vraBuilder.setStateAndConstraintManager(stateManager,constraintManager); + + VehicleRoutingAlgorithm vra = vraBuilder.build(); + vra.setMaxIterations(100); + solution = Solutions.bestOf(vra.searchSolutions()); + + } + + @Test + public void constructionShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + Assert.assertTrue(true); + } + + @Test + public void loadAtBeginningOfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0, analyser.getLoadAtBeginning(route).get(0)); + } + + @Test + public void loadAtBeginningOfRoute2ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + Iterator iterator = solution.getRoutes().iterator(); + iterator.next(); + VehicleRoute route = iterator.next(); + + Assert.assertEquals(0, analyser.getLoadAtBeginning(route).get(0)); + } + + @Test + public void loadAtEnd_OfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(5, analyser.getLoadAtEnd(route).get(0)); + } + + @Test + public void loadAtEnd_OfRoute2ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + Iterator iterator = solution.getRoutes().iterator(); + iterator.next(); + VehicleRoute route = iterator.next(); + + Assert.assertEquals(5, analyser.getLoadAtEnd(route).get(0)); + } + + @Test + public void loadAfterActivity_ofStartActOfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0, analyser.getLoadRightAfterActivity(route.getStart(), route).get(0)); + } + + @Test + public void loadAfterActivity_ofAct1ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(2, analyser.getLoadRightAfterActivity(route.getActivities().get(0), route).get(0)); + } + + @Test + public void loadAfterActivity_ofAct2ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(12, analyser.getLoadRightAfterActivity(route.getActivities().get(1), route).get(0)); + } + + @Test + public void loadAfterActivity_ofAct3ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(2, analyser.getLoadRightAfterActivity(route.getActivities().get(2), route).get(0)); + } + + @Test + public void loadAfterActivity_ofAct4ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(5, analyser.getLoadRightAfterActivity(route.getActivities().get(3), route).get(0)); + } + + @Test + public void loadAfterActivity_ofEndActOfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(5, analyser.getLoadRightAfterActivity(route.getEnd(), route).get(0)); + } + + @Test + public void whatShouldHappenWithAllActStatistics_IfSpecifiedActIsNotInVehicleRoute(){ + /* + there might be the need to add .containsActivity(act) to VehicleRoute + */ + Assert.assertTrue(false); + } + + @Test + public void whatShouldHappenWithAllActStatistics_IfSpecifiedActIsNull(){ + Assert.assertTrue(false); + } + + + + @Test + public void loadBeforeActivity_ofStartActOfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0, analyser.getLoadJustBeforeActivity(route.getStart(), route).get(0)); + } + + @Test + public void loadBeforeActivity_ofAct1ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0, analyser.getLoadJustBeforeActivity(route.getActivities().get(0), route).get(0)); + } + + @Test + public void loadBeforeActivity_ofAct2ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(2, analyser.getLoadJustBeforeActivity(route.getActivities().get(1), route).get(0)); + } + + @Test + public void loadBeforeActivity_ofAct3ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(12, analyser.getLoadJustBeforeActivity(route.getActivities().get(2), route).get(0)); + } + + @Test + public void loadBeforeActivity_ofAct4ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(2, analyser.getLoadJustBeforeActivity(route.getActivities().get(3), route).get(0)); + } + + @Test + public void loadBeforeActivity_ofEndActOfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(5, analyser.getLoadJustBeforeActivity(route.getEnd(), route).get(0)); + } + + @Test + public void maxLoad_OfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(12, analyser.getMaxLoad(route).get(0)); + } + + @Test + public void operationTime_OfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(46. + 40., analyser.getOperationTime(route), 0.01); + } + + @Test + public void waitingTime_OfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(4., analyser.getWaitingTime(route), 0.01); + } + + @Test + public void transportTime_OfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(42., analyser.getTransportTime(route), 0.01); + } + + @Test + public void serviceTime_OfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(40., analyser.getServiceTime(route), 0.01); + } + + @Test + public void distance_OfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(42., analyser.getDistance(route), 0.01); + } + + @Test + public void waitingTime_atStartActOfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0, analyser.getWaitingTimeAtActivity(route.getStart(), route), 0.01); + } + + @Test + public void waitingTime_ofAct1ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(4., analyser.getWaitingTimeAtActivity(route.getActivities().get(0), route), 0.01); + } + + @Test + public void waitingTime_ofAct2ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0., analyser.getWaitingTimeAtActivity(route.getActivities().get(1), route), 0.01); + } + + @Test + public void waitingTime_ofAct3ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0., analyser.getWaitingTimeAtActivity(route.getActivities().get(2), route), 0.01); + } + + @Test + public void waitingTime_ofAct4ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0., analyser.getWaitingTimeAtActivity(route.getActivities().get(3), route), 0.01); + } + + @Test + public void waitingTime_ofEndActOfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0., analyser.getWaitingTimeAtActivity(route.getEnd(), route), 0.01); + } + + @Test + public void distance_atStartActOfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(0, analyser.getDistanceAtActivity(route.getStart(), route), 0.01); + } + + @Test + public void distance_ofAct1ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(6., analyser.getDistanceAtActivity(route.getActivities().get(0), route), 0.01); + } + + @Test + public void distance_ofAct2ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(12., analyser.getDistanceAtActivity(route.getActivities().get(1), route), 0.01); + } + + @Test + public void distance_ofAct3ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(16., analyser.getDistanceAtActivity(route.getActivities().get(2), route), 0.01); + } + + @Test + public void distance_ofAct4ofRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(27., analyser.getDistanceAtActivity(route.getActivities().get(3), route), 0.01); + } + + @Test + public void distance_ofEndActOfRoute1ShouldWork(){ + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager,new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Assert.assertEquals(42., analyser.getDistanceAtActivity(route.getEnd(), route), 0.01); + } + + @Test + public void whatHappensWhenUserSpecifiedOwnEndTime_stateManagerShouldNotOverwriteThis(){ + assertFalse(true); + } + + + +} diff --git a/jsprit-examples/src/main/java/jsprit/examples/VRPWithBackhaulsExample2.java b/jsprit-examples/src/main/java/jsprit/examples/VRPWithBackhaulsExample2.java index b8872dae..caf1f3b4 100644 --- a/jsprit-examples/src/main/java/jsprit/examples/VRPWithBackhaulsExample2.java +++ b/jsprit-examples/src/main/java/jsprit/examples/VRPWithBackhaulsExample2.java @@ -22,11 +22,14 @@ import jsprit.core.algorithm.VehicleRoutingAlgorithm; import jsprit.core.algorithm.VehicleRoutingAlgorithmBuilder; import jsprit.core.algorithm.selector.SelectBest; import jsprit.core.algorithm.state.StateManager; +import jsprit.core.analysis.SolutionAnalyser; import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.constraint.ConstraintManager; import jsprit.core.problem.constraint.ServiceDeliveriesFirstConstraint; import jsprit.core.problem.io.VrpXMLReader; import jsprit.core.problem.solution.VehicleRoutingProblemSolution; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.TourActivity; import jsprit.core.reporting.SolutionPrinter; import jsprit.util.Examples; @@ -58,7 +61,7 @@ public class VRPWithBackhaulsExample2 { /* * Finally, the problem can be built. By default, transportCosts are crowFlyDistances (as usually used for vrp-instances). */ - VehicleRoutingProblem vrp = vrpBuilder.build(); + final VehicleRoutingProblem vrp = vrpBuilder.build(); new Plotter(vrp).plot("output/vrpwbh_christophides_vrpnc1.png", "pd_vrpnc1"); @@ -105,9 +108,40 @@ public class VRPWithBackhaulsExample2 { Plotter plotter = new Plotter(vrp, solution); plotter.setLabel(Label.SIZE); plotter.plot("output/vrpwbh_christophides_vrpnc1_solution.png","vrpwbh_vrpnc1"); - - - - } + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution.getRoutes(),stateManager, new SolutionAnalyser.DistanceCalculator() { + + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + + }); + + for(VehicleRoute route : solution.getRoutes()){ + System.out.println("------"); + System.out.println("vehicleId: " + route.getVehicle().getId()); + System.out.println("vehicleCapacity: " + route.getVehicle().getType().getCapacityDimensions() + " maxLoad: " + analyser.getMaxLoad(route)); + System.out.println("totalDistance: " + analyser.getDistance(route)); + System.out.println("waitingTime: " + analyser.getWaitingTime(route)); + System.out.println("load@beginning: " + analyser.getLoadAtBeginning(route)); + System.out.println("load@end: " + analyser.getLoadAtEnd(route)); + System.out.println("operationTime: " + analyser.getOperationTime(route)); + System.out.println("serviceTime: " + analyser.getServiceTime(route)); + System.out.println("transportTime: " + analyser.getTransportTime(route)); + + System.out.println("dist@" + route.getStart().getLocationId() + ": " + analyser.getDistanceAtActivity(route.getStart(),route)); + for(TourActivity act : route.getActivities()){ + System.out.println("--"); + System.out.println("actType: " + act.getName() + " demand: " + act.getSize()); + System.out.println("dist@" + act.getLocationId() + ": " + analyser.getDistanceAtActivity(act,route)); + System.out.println("load(before)@" + act.getLocationId() + ": " + analyser.getLoadJustBeforeActivity(act,route)); + System.out.println("load(after)@" + act.getLocationId() + ": " + analyser.getLoadRightAfterActivity(act, route)); + } + System.out.println("--"); + System.out.println("dist@" + route.getEnd().getLocationId() + ": " + analyser.getDistanceAtActivity(route.getEnd(),route)); + } + + } }