From b530a7c85d482e3df30c18774c65d934ab247d40 Mon Sep 17 00:00:00 2001 From: Kandel Irina Date: Thu, 1 Feb 2018 18:03:59 +0200 Subject: [PATCH 1/8] pass prev activity --- .../algorithm/state/UpdateMaxTimeInVehicle.java | 7 ++++++- .../state/UpdatePracticalTimeWindows.java | 7 ++++++- ...ateVehicleDependentPracticalTimeWindows.java | 17 +++++++++++------ .../VehicleDependentTimeWindowConstraints.java | 9 +++++++-- 4 files changed, 30 insertions(+), 10 deletions(-) diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateMaxTimeInVehicle.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateMaxTimeInVehicle.java index 3496f3a1..9ae37d36 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateMaxTimeInVehicle.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateMaxTimeInVehicle.java @@ -57,6 +57,8 @@ public class UpdateMaxTimeInVehicle implements StateUpdater, ActivityVisitor{ private final VehicleRoutingActivityCosts activityCosts; + private TourActivity prevTourActivity = null; + private UpdateVehicleDependentPracticalTimeWindows.VehiclesToUpdate vehiclesToUpdate = new UpdateVehicleDependentPracticalTimeWindows.VehiclesToUpdate() { @Override @@ -98,6 +100,7 @@ public class UpdateMaxTimeInVehicle implements StateUpdater, ActivityVisitor{ prevActEndTimes[vehicleIndex] = v.getEarliestDeparture(); prevActLocations[vehicleIndex] = v.getStartLocation(); } + prevTourActivity = route.getStart(); } @Override @@ -111,7 +114,7 @@ public class UpdateMaxTimeInVehicle implements StateUpdater, ActivityVisitor{ double activityArrival = prevActEndTimes[v.getVehicleTypeIdentifier().getIndex()] + transportTime.getTransportTime(prevActLocation,activity.getLocation(),prevActEndTime,route.getDriver(),v); double activityStart = Math.max(activityArrival,activity.getTheoreticalEarliestOperationStartTime()); memorizeActStart(activity,v,activityStart); - double activityEnd = activityStart + activityCosts.getActivityDuration(null, activity, activityArrival, route.getDriver(), v); + double activityEnd = activityStart + activityCosts.getActivityDuration(prevTourActivity, activity, activityArrival, route.getDriver(), v); Map openPickups = openPickupEndTimesPerVehicle.get(vehicleIndex); if (activity instanceof ServiceActivity || activity instanceof PickupActivity) { openPickups.put(((TourActivity.JobActivity) activity).getJob(), activityEnd); @@ -129,6 +132,8 @@ public class UpdateMaxTimeInVehicle implements StateUpdater, ActivityVisitor{ prevActEndTimes[vehicleIndex] = activityEnd; } + prevTourActivity = activity; + } private double getMaxTimeInVehicle(TourActivity activity) { diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdatePracticalTimeWindows.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdatePracticalTimeWindows.java index a6ee4abf..29204573 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdatePracticalTimeWindows.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdatePracticalTimeWindows.java @@ -56,9 +56,14 @@ class UpdatePracticalTimeWindows implements ReverseActivityVisitor, StateUpdater prevAct = route.getEnd(); } + @Override public void visit(TourActivity activity) { - double potentialLatestArrivalTimeAtCurrAct = latestArrTimeAtPrevAct - transportCosts.getBackwardTransportTime(activity.getLocation(), prevAct.getLocation(), latestArrTimeAtPrevAct, route.getDriver(), route.getVehicle()) - activityCosts.getActivityDuration(prevAct, activity,latestArrTimeAtPrevAct,route.getDriver(),route.getVehicle()); + double potentialLatestArrivalTimeAtCurrAct = + latestArrTimeAtPrevAct - + transportCosts.getBackwardTransportTime(activity.getLocation(), prevAct.getLocation(), latestArrTimeAtPrevAct, route.getDriver(), route.getVehicle()) - + activityCosts.getActivityDuration(activity, prevAct, latestArrTimeAtPrevAct,route.getDriver(),route.getVehicle()); + double latestArrivalTime = Math.min(activity.getTheoreticalLatestOperationStartTime(), potentialLatestArrivalTimeAtCurrAct); states.putInternalTypedActivityState(activity, InternalStates.LATEST_OPERATION_START_TIME, latestArrivalTime); diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java index e361467c..a0eb6b2f 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java @@ -28,17 +28,22 @@ import com.graphhopper.jsprit.core.problem.vehicle.Vehicle; import java.util.Arrays; import java.util.Collection; -import java.util.Iterator; public class UpdateVehicleDependentPracticalTimeWindows implements RouteVisitor, StateUpdater { @Override public void visit(VehicleRoute route) { begin(route); - Iterator revIterator = route.getTourActivities().reverseActivityIterator(); - while (revIterator.hasNext()) { - visit(revIterator.next()); + + for (int i = route.getTourActivities().getActivities().size() - 1; i >= 0; --i) { + + if (i > 1) { + visit(route.getTourActivities().getActivities().get(i), route.getTourActivities().getActivities().get(i - 1)); + } else { + visit(route.getTourActivities().getActivities().get(i), route.getStart()); + } } + finish(); } @@ -99,12 +104,12 @@ public class UpdateVehicleDependentPracticalTimeWindows implements RouteVisitor, } - public void visit(TourActivity activity) { + public void visit(TourActivity activity, TourActivity prev) { for (Vehicle vehicle : vehicles) { double latestArrTimeAtPrevAct = latest_arrTimes_at_prevAct[vehicle.getVehicleTypeIdentifier().getIndex()]; Location prevLocation = location_of_prevAct[vehicle.getVehicleTypeIdentifier().getIndex()]; double potentialLatestArrivalTimeAtCurrAct = latestArrTimeAtPrevAct - transportCosts.getBackwardTransportTime(activity.getLocation(), prevLocation, - latestArrTimeAtPrevAct, route.getDriver(), vehicle) - activityCosts.getActivityDuration(null, activity, latestArrTimeAtPrevAct, route.getDriver(), route.getVehicle()); + latestArrTimeAtPrevAct, route.getDriver(), vehicle) - activityCosts.getActivityDuration(prev, activity, latestArrTimeAtPrevAct, route.getDriver(), route.getVehicle()); double latestArrivalTime = Math.min(activity.getTheoreticalLatestOperationStartTime(), potentialLatestArrivalTimeAtCurrAct); if (latestArrivalTime < activity.getTheoreticalEarliestOperationStartTime()) { stateManager.putTypedInternalRouteState(route, vehicle, InternalStates.SWITCH_NOT_FEASIBLE, true); diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java index 5d0d1ffb..c0fd8d68 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java @@ -108,12 +108,17 @@ public class VehicleDependentTimeWindowConstraints implements HardActivityConstr return ConstraintsStatus.NOT_FULFILLED; } // log.info("check insertion of " + newAct + " between " + prevAct + " and " + nextAct + ". prevActDepTime=" + prevActDepTime); + double routingFromNewToNext = routingCosts.getBackwardTransportTime(newAct.getLocation(), nextActLocation, latestArrTimeAtNextAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); double arrTimeAtNewAct = prevActDepTime + routingCosts.getTransportTime(prevAct.getLocation(), newAct.getLocation(), prevActDepTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); double endTimeAtNewAct = Math.max(arrTimeAtNewAct, newAct.getTheoreticalEarliestOperationStartTime()) + activityCosts.getActivityDuration(prevAct, newAct, arrTimeAtNewAct,iFacts.getNewDriver(),iFacts.getNewVehicle()); + double savingsInNextActivityDuration = + activityCosts.getActivityDuration(prevAct, nextAct, arrTimeAtNextOnDirectRouteWithNewVehicle, iFacts.getNewDriver(), iFacts.getNewVehicle()) - + activityCosts.getActivityDuration(newAct, nextAct, endTimeAtNewAct + routingFromNewToNext, iFacts.getNewDriver(), iFacts.getNewVehicle()); + double latestArrTimeAtNewAct = Math.min(newAct.getTheoreticalLatestOperationStartTime(), - latestArrTimeAtNextAct - - routingCosts.getBackwardTransportTime(newAct.getLocation(), nextActLocation, latestArrTimeAtNextAct, iFacts.getNewDriver(), iFacts.getNewVehicle()) + latestArrTimeAtNextAct + savingsInNextActivityDuration - + routingFromNewToNext - activityCosts.getActivityDuration(prevAct, newAct, arrTimeAtNewAct, iFacts.getNewDriver(), iFacts.getNewVehicle()) ); From 5635cd572b3e930c6c2eb24886252afcac955ca9 Mon Sep 17 00:00:00 2001 From: Kandel Irina Date: Thu, 1 Feb 2018 18:50:41 +0200 Subject: [PATCH 2/8] fix --- .../state/UpdateVehicleDependentPracticalTimeWindows.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java index a0eb6b2f..cdab7965 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java @@ -37,7 +37,7 @@ public class UpdateVehicleDependentPracticalTimeWindows implements RouteVisitor, for (int i = route.getTourActivities().getActivities().size() - 1; i >= 0; --i) { - if (i > 1) { + if (i > 0) { visit(route.getTourActivities().getActivities().get(i), route.getTourActivities().getActivities().get(i - 1)); } else { visit(route.getTourActivities().getActivities().get(i), route.getStart()); From b47547afdb6adaafdc51475705d18663d6d53570 Mon Sep 17 00:00:00 2001 From: Kandel Irina Date: Thu, 1 Feb 2018 19:21:04 +0200 Subject: [PATCH 3/8] test full flow --- .../TestAlgorithmSquashActivityTimes.java | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 jsprit-io/src/test/java/com/graphhopper/jsprit/io/algorithm/TestAlgorithmSquashActivityTimes.java diff --git a/jsprit-io/src/test/java/com/graphhopper/jsprit/io/algorithm/TestAlgorithmSquashActivityTimes.java b/jsprit-io/src/test/java/com/graphhopper/jsprit/io/algorithm/TestAlgorithmSquashActivityTimes.java new file mode 100644 index 00000000..faf295f9 --- /dev/null +++ b/jsprit-io/src/test/java/com/graphhopper/jsprit/io/algorithm/TestAlgorithmSquashActivityTimes.java @@ -0,0 +1,92 @@ +package com.graphhopper.jsprit.io.algorithm; + +import com.graphhopper.jsprit.core.algorithm.VehicleRoutingAlgorithm; +import com.graphhopper.jsprit.core.algorithm.state.StateManager; +import com.graphhopper.jsprit.core.problem.Location; +import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem; +import com.graphhopper.jsprit.core.problem.constraint.ConstraintManager; +import com.graphhopper.jsprit.core.problem.constraint.HardActivityConstraint; +import com.graphhopper.jsprit.core.problem.cost.VehicleRoutingActivityCosts; +import com.graphhopper.jsprit.core.problem.driver.Driver; +import com.graphhopper.jsprit.core.problem.job.Delivery; +import com.graphhopper.jsprit.core.problem.job.Job; +import com.graphhopper.jsprit.core.problem.misc.JobInsertionContext; +import com.graphhopper.jsprit.core.problem.solution.VehicleRoutingProblemSolution; +import com.graphhopper.jsprit.core.problem.solution.route.activity.BreakActivity; +import com.graphhopper.jsprit.core.problem.solution.route.activity.TimeWindow; +import com.graphhopper.jsprit.core.problem.solution.route.activity.TourActivity; +import com.graphhopper.jsprit.core.problem.vehicle.Vehicle; +import com.graphhopper.jsprit.core.problem.vehicle.VehicleImpl; +import com.graphhopper.jsprit.core.problem.vehicle.VehicleTypeImpl; +import com.graphhopper.jsprit.core.util.Solutions; +import org.junit.Test; + +import java.util.Random; +import java.util.UUID; + +import static org.junit.Assert.assertEquals; + +public class TestAlgorithmSquashActivityTimes { + + @Test + public void testSquash () { + VehicleRoutingActivityCosts activityCost = new VehicleRoutingActivityCosts() { + @Override + public double getActivityCost(TourActivity prevAct, TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) { + return getActivityDuration(prevAct, tourAct, arrivalTime, driver, vehicle); + } + + @Override + public double getActivityDuration(TourActivity from, TourActivity to, double startTime, Driver driver, Vehicle vehicle) { + if (from != null && !(to instanceof BreakActivity || from instanceof BreakActivity) && from.getLocation().getCoordinate().equals(to.getLocation().getCoordinate())) { + return 1; + } + + return to.getOperationTime(); + } + }; + final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() + .addVehicle(VehicleImpl.Builder.newInstance("vehicle") + .setStartLocation(Location.newInstance(1.521801, 42.506285)) + .setEarliestStart(0) + .setLatestArrival(10).setType(VehicleTypeImpl.Builder.newInstance(UUID.randomUUID().toString()).addCapacityDimension(0, Integer.MAX_VALUE).build()) + .setReturnToDepot(false) + .build()) + .addJob(getJobs(0, 10, 1, 7)) + .addJob(getJobs(0, 10, 1, 7)) + .addJob(getJobs(0, 10, 1, 7)) + .addJob(getJobs(0, 10, 1, 6)) + .setActivityCosts(activityCost) + .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) + .build(); + + StateManager stateManager = new StateManager(vrp); + + ConstraintManager constraintManager = new ConstraintManager (vrp, stateManager) { + @Override + public HardActivityConstraint.ConstraintsStatus fulfilled(JobInsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime){ + if (newAct instanceof BreakActivity && newAct.getLocation().equals(nextAct.getLocation())) + return ConstraintsStatus.NOT_FULFILLED; + + return super.fulfilled(iFacts, prevAct, newAct, nextAct, prevActDepTime); + } + }; + + final VehicleRoutingAlgorithm algorithm = VehicleRoutingAlgorithms.readAndCreateAlgorithm(vrp, Runtime.getRuntime().availableProcessors() + 1, getClass().getResource("algorithmConfig_withoutIterations.xml").getFile(), stateManager, constraintManager, null); + + final VehicleRoutingProblemSolution problemSolution = Solutions.bestOf(algorithm.searchSolutions()); + + assertEquals(problemSolution.getUnassignedJobs().size(), 0); + assertEquals(problemSolution.getRoutes().iterator().next().getTourActivities().getActivities().size(), 4); + } + + private Job getJobs(int start, int end, int capacity, int duration) { + return Delivery.Builder.newInstance("service_" + new Random().nextInt()) + .setLocation(Location.newInstance(1.52181, 42.5062)) + .setServiceTime(duration) + .addTimeWindow(new TimeWindow(start, end)) + .addSizeDimension(0, capacity) + .setName(UUID.randomUUID().toString()) + .build(); + } +} From f129829f93601d70c285e744906e958d693f8251 Mon Sep 17 00:00:00 2001 From: Kandel Irina Date: Fri, 2 Feb 2018 08:25:34 +0200 Subject: [PATCH 4/8] min added --- .../constraint/VehicleDependentTimeWindowConstraints.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java index c0fd8d68..5ddf95f2 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java @@ -117,7 +117,7 @@ public class VehicleDependentTimeWindowConstraints implements HardActivityConstr double latestArrTimeAtNewAct = Math.min(newAct.getTheoreticalLatestOperationStartTime(), - latestArrTimeAtNextAct + savingsInNextActivityDuration - + Math.min(nextAct.getTheoreticalLatestOperationStartTime(), latestArrTimeAtNextAct + savingsInNextActivityDuration) - routingFromNewToNext - activityCosts.getActivityDuration(prevAct, newAct, arrTimeAtNewAct, iFacts.getNewDriver(), iFacts.getNewVehicle()) ); From e64e4d204192a464a43af70f33932fcd09876463 Mon Sep 17 00:00:00 2001 From: Kandel Irina Date: Sun, 4 Feb 2018 09:06:34 +0200 Subject: [PATCH 5/8] fixes --- ...VehicleDependentTimeWindowConstraints.java | 4 +- ...wWithStartTimeAndMaxOperationTimeTest.java | 106 ++++++++++++++++++ 2 files changed, 108 insertions(+), 2 deletions(-) diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java index 5ddf95f2..ba1cebde 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowConstraints.java @@ -115,10 +115,10 @@ public class VehicleDependentTimeWindowConstraints implements HardActivityConstr activityCosts.getActivityDuration(prevAct, nextAct, arrTimeAtNextOnDirectRouteWithNewVehicle, iFacts.getNewDriver(), iFacts.getNewVehicle()) - activityCosts.getActivityDuration(newAct, nextAct, endTimeAtNewAct + routingFromNewToNext, iFacts.getNewDriver(), iFacts.getNewVehicle()); + latestArrTimeAtNextAct = Math.min(nextAct.getTheoreticalLatestOperationStartTime(), latestArrTimeAtNextAct + savingsInNextActivityDuration); double latestArrTimeAtNewAct = Math.min(newAct.getTheoreticalLatestOperationStartTime(), - Math.min(nextAct.getTheoreticalLatestOperationStartTime(), latestArrTimeAtNextAct + savingsInNextActivityDuration) - - routingFromNewToNext + latestArrTimeAtNextAct - routingFromNewToNext - activityCosts.getActivityDuration(prevAct, newAct, arrTimeAtNewAct, iFacts.getNewDriver(), iFacts.getNewVehicle()) ); diff --git a/jsprit-core/src/test/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest.java b/jsprit-core/src/test/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest.java index 373b0edd..488fea1b 100644 --- a/jsprit-core/src/test/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest.java +++ b/jsprit-core/src/test/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest.java @@ -26,11 +26,16 @@ import com.graphhopper.jsprit.core.problem.*; import com.graphhopper.jsprit.core.problem.cost.VehicleRoutingActivityCosts; import com.graphhopper.jsprit.core.problem.cost.VehicleRoutingTransportCosts; import com.graphhopper.jsprit.core.problem.cost.WaitingTimeCosts; +import com.graphhopper.jsprit.core.problem.driver.Driver; import com.graphhopper.jsprit.core.problem.job.Job; import com.graphhopper.jsprit.core.problem.job.Service; import com.graphhopper.jsprit.core.problem.misc.JobInsertionContext; import com.graphhopper.jsprit.core.problem.solution.route.VehicleRoute; +import com.graphhopper.jsprit.core.problem.solution.route.activity.BreakActivity; +import com.graphhopper.jsprit.core.problem.solution.route.activity.DeliveryActivity; import com.graphhopper.jsprit.core.problem.solution.route.activity.PickupService; +import com.graphhopper.jsprit.core.problem.solution.route.activity.TourActivity; +import com.graphhopper.jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter; import com.graphhopper.jsprit.core.problem.vehicle.*; import com.graphhopper.jsprit.core.util.CostFactory; import org.junit.Before; @@ -39,6 +44,8 @@ import org.junit.Test; import java.util.*; import static org.junit.Assert.*; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; /** * unit tests to test vehicle dependent time-windows @@ -338,5 +345,104 @@ public class VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest { } + /* + * driver TW: 5 - 10 + * prev task 0 - 5 + * new and next acts at same location, tw 5-10, activity duration 4 + * |--- newAct ---| + * |--- nextAct ---| + */ + @Test + public void testSquash () { + Random random = new Random(); + final double fixedCostAtSameLocation = random.nextDouble(), + travelTime = random.nextDouble(), + firstActDuration = 5, nextActivitiesDuration = 4.0, + vehicleLatestArrival = firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 3; + + Location locationFirst = Location.newInstance(random.nextDouble(), random.nextDouble()); + Location locationSecond = Location.newInstance(random.nextDouble(), random.nextDouble()); + + Vehicle vehicle = mock(Vehicle.class); + when(vehicle.getLatestArrival()).thenReturn(vehicleLatestArrival); + + JobInsertionContext iFacts = mock(JobInsertionContext.class); + when(iFacts.getNewVehicle()).thenReturn(vehicle); + + RouteAndActivityStateGetter routeAndActivityStateGetter = mock(RouteAndActivityStateGetter.class); + + TourActivity prevAct = mock(DeliveryActivity.class), + newAct = mock(DeliveryActivity.class), + nextAct = mock(DeliveryActivity.class); + + when(prevAct.getTheoreticalEarliestOperationStartTime()).thenReturn(.0); + when(prevAct.getTheoreticalLatestOperationStartTime()).thenReturn(firstActDuration); + when(prevAct.getOperationTime()).thenReturn(firstActDuration); + when(prevAct.getLocation()).thenReturn(locationFirst); + + when(newAct.getTheoreticalEarliestOperationStartTime()).thenReturn(firstActDuration); + when(newAct.getTheoreticalLatestOperationStartTime()).thenReturn(firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 2); + when(newAct.getOperationTime()).thenReturn(nextActivitiesDuration); + when(newAct.getLocation()).thenReturn(locationSecond); + + when(nextAct.getTheoreticalEarliestOperationStartTime()).thenReturn(firstActDuration); + when(nextAct.getTheoreticalLatestOperationStartTime()).thenReturn(firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 2); + when(nextAct.getOperationTime()).thenReturn(nextActivitiesDuration); + when(nextAct.getLocation()).thenReturn(locationSecond); + + when(routeAndActivityStateGetter.getActivityState(nextAct, vehicle, InternalStates.LATEST_OPERATION_START_TIME, Double.class)).thenReturn(vehicleLatestArrival - travelTime - nextActivitiesDuration); + + final VehicleDependentTimeWindowConstraints timeWindowConstraints = new VehicleDependentTimeWindowConstraints(routeAndActivityStateGetter, getTransportCosts(travelTime), getActivityCost(fixedCostAtSameLocation)); + + assertEquals(timeWindowConstraints.fulfilled(iFacts, prevAct, newAct, nextAct, 5.0), HardActivityConstraint.ConstraintsStatus.FULFILLED); + } + + private VehicleRoutingActivityCosts getActivityCost(final double fixedCostAtSameLocation) { + return new VehicleRoutingActivityCosts() { + @Override + public double getActivityCost(TourActivity prevAct, TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) { + return getActivityDuration(prevAct, tourAct, arrivalTime, driver, vehicle); + } + + @Override + public double getActivityDuration(TourActivity from, TourActivity to, double startTime, Driver driver, Vehicle vehicle) { + if (from != null && !(to instanceof BreakActivity || from instanceof BreakActivity) && from.getLocation().getCoordinate().equals(to.getLocation().getCoordinate())) { + return fixedCostAtSameLocation; + } + + return to.getOperationTime(); + } + }; + } + + public VehicleRoutingTransportCosts getTransportCosts(final double travelTime) { + return new VehicleRoutingTransportCosts() { + + @Override + public double getDistance(Location from, Location to, double departureTime, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + + @Override + public double getTransportTime(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + + @Override + public double getTransportCost(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + + @Override + public double getBackwardTransportTime(Location from, Location to, double arrivalTime, Driver driver, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + + @Override + public double getBackwardTransportCost(Location from, Location to, double arrivalTime, Driver driver, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + }; + } } From efbf3c03625b4ebc49589ff469c6e3143dd4ba38 Mon Sep 17 00:00:00 2001 From: Kandel Irina Date: Sun, 4 Feb 2018 10:27:21 +0200 Subject: [PATCH 6/8] tests added --- .../UpdateVehicleDependentTimeWindowTest.java | 91 ++++++++++++- ...wWithStartTimeAndMaxOperationTimeTest.java | 123 ++++++++++++++---- 2 files changed, 184 insertions(+), 30 deletions(-) diff --git a/jsprit-core/src/test/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentTimeWindowTest.java b/jsprit-core/src/test/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentTimeWindowTest.java index a07d61e5..096ada4f 100644 --- a/jsprit-core/src/test/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentTimeWindowTest.java +++ b/jsprit-core/src/test/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentTimeWindowTest.java @@ -25,14 +25,15 @@ import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem; import com.graphhopper.jsprit.core.problem.cost.VehicleRoutingActivityCosts; import com.graphhopper.jsprit.core.problem.cost.VehicleRoutingTransportCosts; import com.graphhopper.jsprit.core.problem.cost.WaitingTimeCosts; +import com.graphhopper.jsprit.core.problem.driver.Driver; +import com.graphhopper.jsprit.core.problem.job.Delivery; import com.graphhopper.jsprit.core.problem.job.Job; +import com.graphhopper.jsprit.core.problem.job.Pickup; import com.graphhopper.jsprit.core.problem.job.Service; import com.graphhopper.jsprit.core.problem.solution.route.VehicleRoute; import com.graphhopper.jsprit.core.problem.solution.route.activity.TimeWindow; -import com.graphhopper.jsprit.core.problem.vehicle.FiniteFleetManagerFactory; -import com.graphhopper.jsprit.core.problem.vehicle.Vehicle; -import com.graphhopper.jsprit.core.problem.vehicle.VehicleFleetManager; -import com.graphhopper.jsprit.core.problem.vehicle.VehicleImpl; +import com.graphhopper.jsprit.core.problem.solution.route.activity.TourActivity; +import com.graphhopper.jsprit.core.problem.vehicle.*; import com.graphhopper.jsprit.core.util.Coordinate; import com.graphhopper.jsprit.core.util.CostFactory; import org.junit.Assert; @@ -42,6 +43,7 @@ import org.junit.Test; import java.util.*; import static org.junit.Assert.*; +import static org.mockito.Mockito.mock; /** * unit tests to test vehicle dependent time window updater @@ -268,5 +270,86 @@ public class UpdateVehicleDependentTimeWindowTest { } + Random random = new Random(); + + @Test + public void testSquash () { + Location pickupLocation = Location.newInstance(random.nextDouble(), random.nextDouble()); + final double fixedDurationInSameLocation = random.nextDouble(), activityDuration = 10 + random.nextDouble(), travelTime = random.nextDouble(); + + Pickup pickup = Pickup.Builder.newInstance("pick1").setLocation(pickupLocation).setTimeWindow(TimeWindow.newInstance(0, 40)).setServiceTime(activityDuration).build(); + Pickup pickup2 = Pickup.Builder.newInstance("pick2").setLocation(pickupLocation).setTimeWindow(TimeWindow.newInstance(0, 40)).setServiceTime(activityDuration).build(); + + Delivery delivery = Delivery.Builder.newInstance("del1").setLocation(Location.newInstance(random.nextDouble(), random.nextDouble())).setTimeWindow(TimeWindow.newInstance(0, 40)).setServiceTime(activityDuration).build(); + Delivery delivery2 = Delivery.Builder.newInstance("del2").setLocation(Location.newInstance(random.nextDouble(), random.nextDouble())).setTimeWindow(TimeWindow.newInstance(0, 40)).setServiceTime(activityDuration).build(); + + Vehicle vehicle = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(random.nextDouble(), random.nextDouble())).setType(VehicleTypeImpl.Builder.newInstance("type").build()).build(); + + VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); + final VehicleRoutingProblem vrp = vrpBuilder.addJob(pickup).addJob(pickup2).addJob(delivery).addJob(delivery2).addVehicle(vehicle).setFleetSize(VehicleRoutingProblem.FleetSize.FINITE).build(); + + route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class)).setJobActivityFactory(new JobActivityFactory() { + @Override + public List createActivities(Job job) { + return vrp.copyAndGetActivities(job); + } + }).addService(pickup).addService(pickup2).addService(delivery).addService(delivery2).build(); + + + + VehicleRoutingTransportCosts transportCosts = getTransportCosts(travelTime); + + activityCosts = new WaitingTimeCosts() { + @Override + public double getActivityDuration(TourActivity prevAct, TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) { + return prevAct != null && prevAct.getLocation().getCoordinate().equals(tourAct.getLocation().getCoordinate()) ? fixedDurationInSameLocation : tourAct.getOperationTime(); + } + }; + + stateManager = new StateManager(vrp); + + final UpdateVehicleDependentPracticalTimeWindows timeWindowsUpdater = new UpdateVehicleDependentPracticalTimeWindows(stateManager, transportCosts, activityCosts); + timeWindowsUpdater.visit(route); + + double latestArrivalAt4Act = 40, + latestArrivalAt3Act = latestArrivalAt4Act - activityDuration - travelTime, + latestArrivalAt2Act = latestArrivalAt3Act - fixedDurationInSameLocation - travelTime, + latestArrivalAt1Act = latestArrivalAt2Act - activityDuration; + + assertEquals(stateManager.getActivityState(route.getActivities().get(3), vehicle, InternalStates.LATEST_OPERATION_START_TIME, Double.class), latestArrivalAt4Act, 0.001); + assertEquals(stateManager.getActivityState(route.getActivities().get(2), vehicle, InternalStates.LATEST_OPERATION_START_TIME, Double.class), latestArrivalAt3Act, 0.001); + assertEquals(stateManager.getActivityState(route.getActivities().get(1), vehicle, InternalStates.LATEST_OPERATION_START_TIME, Double.class), latestArrivalAt2Act, 0.001); + assertEquals(stateManager.getActivityState(route.getActivities().get(0), vehicle, InternalStates.LATEST_OPERATION_START_TIME, Double.class), latestArrivalAt1Act, 0.001); + } + + public VehicleRoutingTransportCosts getTransportCosts(final double travelTime) { + return new VehicleRoutingTransportCosts() { + + @Override + public double getDistance(Location from, Location to, double departureTime, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + + @Override + public double getTransportTime(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + + @Override + public double getTransportCost(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + + @Override + public double getBackwardTransportTime(Location from, Location to, double arrivalTime, Driver driver, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + + @Override + public double getBackwardTransportCost(Location from, Location to, double arrivalTime, Driver driver, Vehicle vehicle) { + return from.getCoordinate().equals(to.getCoordinate()) ? 0 : travelTime; + } + }; + } } diff --git a/jsprit-core/src/test/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest.java b/jsprit-core/src/test/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest.java index 488fea1b..8e861715 100644 --- a/jsprit-core/src/test/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest.java +++ b/jsprit-core/src/test/java/com/graphhopper/jsprit/core/problem/constraint/VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest.java @@ -31,10 +31,7 @@ import com.graphhopper.jsprit.core.problem.job.Job; import com.graphhopper.jsprit.core.problem.job.Service; import com.graphhopper.jsprit.core.problem.misc.JobInsertionContext; import com.graphhopper.jsprit.core.problem.solution.route.VehicleRoute; -import com.graphhopper.jsprit.core.problem.solution.route.activity.BreakActivity; -import com.graphhopper.jsprit.core.problem.solution.route.activity.DeliveryActivity; -import com.graphhopper.jsprit.core.problem.solution.route.activity.PickupService; -import com.graphhopper.jsprit.core.problem.solution.route.activity.TourActivity; +import com.graphhopper.jsprit.core.problem.solution.route.activity.*; import com.graphhopper.jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter; import com.graphhopper.jsprit.core.problem.vehicle.*; import com.graphhopper.jsprit.core.util.CostFactory; @@ -353,13 +350,13 @@ public class VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest { * |--- nextAct ---| */ + Random random = new Random(); @Test - public void testSquash () { - Random random = new Random(); + public void testSquashNotEnd () { final double fixedCostAtSameLocation = random.nextDouble(), travelTime = random.nextDouble(), - firstActDuration = 5, nextActivitiesDuration = 4.0, - vehicleLatestArrival = firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 3; + firstActDuration = 5, nextActivitiesDuration = 4.0, + vehicleLatestArrival = firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 3; Location locationFirst = Location.newInstance(random.nextDouble(), random.nextDouble()); Location locationSecond = Location.newInstance(random.nextDouble(), random.nextDouble()); @@ -372,24 +369,9 @@ public class VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest { RouteAndActivityStateGetter routeAndActivityStateGetter = mock(RouteAndActivityStateGetter.class); - TourActivity prevAct = mock(DeliveryActivity.class), - newAct = mock(DeliveryActivity.class), - nextAct = mock(DeliveryActivity.class); - - when(prevAct.getTheoreticalEarliestOperationStartTime()).thenReturn(.0); - when(prevAct.getTheoreticalLatestOperationStartTime()).thenReturn(firstActDuration); - when(prevAct.getOperationTime()).thenReturn(firstActDuration); - when(prevAct.getLocation()).thenReturn(locationFirst); - - when(newAct.getTheoreticalEarliestOperationStartTime()).thenReturn(firstActDuration); - when(newAct.getTheoreticalLatestOperationStartTime()).thenReturn(firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 2); - when(newAct.getOperationTime()).thenReturn(nextActivitiesDuration); - when(newAct.getLocation()).thenReturn(locationSecond); - - when(nextAct.getTheoreticalEarliestOperationStartTime()).thenReturn(firstActDuration); - when(nextAct.getTheoreticalLatestOperationStartTime()).thenReturn(firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 2); - when(nextAct.getOperationTime()).thenReturn(nextActivitiesDuration); - when(nextAct.getLocation()).thenReturn(locationSecond); + TourActivity prevAct = getTourActivity(.0, firstActDuration, firstActDuration, locationFirst); + TourActivity newAct = getTourActivity(firstActDuration, firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 2, nextActivitiesDuration, locationSecond); + TourActivity nextAct = getTourActivity(firstActDuration, firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 2, nextActivitiesDuration, locationSecond); when(routeAndActivityStateGetter.getActivityState(nextAct, vehicle, InternalStates.LATEST_OPERATION_START_TIME, Double.class)).thenReturn(vehicleLatestArrival - travelTime - nextActivitiesDuration); @@ -398,6 +380,95 @@ public class VehicleDependentTimeWindowWithStartTimeAndMaxOperationTimeTest { assertEquals(timeWindowConstraints.fulfilled(iFacts, prevAct, newAct, nextAct, 5.0), HardActivityConstraint.ConstraintsStatus.FULFILLED); } + @Test + public void testNoSquashEnd () { + final double fixedCostAtSameLocation = random.nextDouble(), + travelTime = random.nextDouble(), + firstActDuration = 5, nextActivitiesDuration = 4.0, + vehicleLatestArrival = firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 3; + + Location locationFirst = Location.newInstance(random.nextDouble(), random.nextDouble()); + Location locationSecond = Location.newInstance(random.nextDouble(), random.nextDouble()); + + Vehicle vehicle = mock(Vehicle.class); + when(vehicle.getLatestArrival()).thenReturn(vehicleLatestArrival); + when(vehicle.isReturnToDepot()).thenReturn(false); + + JobInsertionContext iFacts = mock(JobInsertionContext.class); + when(iFacts.getNewVehicle()).thenReturn(vehicle); + + TourActivity prevAct = getTourActivity(.0, firstActDuration, firstActDuration, locationFirst); + TourActivity newAct = getTourActivity(firstActDuration, firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 2, nextActivitiesDuration, locationSecond); + End end = new End(locationSecond, firstActDuration, firstActDuration + nextActivitiesDuration + fixedCostAtSameLocation + travelTime * 2); + + final VehicleDependentTimeWindowConstraints timeWindowConstraints = new VehicleDependentTimeWindowConstraints(mock(RouteAndActivityStateGetter.class), getTransportCosts(travelTime), getActivityCost(fixedCostAtSameLocation)); + + assertEquals(timeWindowConstraints.fulfilled(iFacts, prevAct, newAct, end, 5.0), HardActivityConstraint.ConstraintsStatus.FULFILLED); + } + + @Test + public void testSquashEndReturnToDepot () { + final double fixedCostAtSameLocation = random.nextDouble(), + travelTime = random.nextDouble(), + firstActDuration = 5.0, newActivityDuration = 4.0, + vehicleLatestArrival = firstActDuration + fixedCostAtSameLocation + travelTime; + + Location location = Location.newInstance(random.nextDouble(), random.nextDouble()); + Location depot = Location.newInstance(random.nextDouble(), random.nextDouble()); + + Vehicle vehicle = mock(Vehicle.class); + when(vehicle.getLatestArrival()).thenReturn(vehicleLatestArrival); + when(vehicle.isReturnToDepot()).thenReturn(true); + when(vehicle.getEndLocation()).thenReturn(depot); + + JobInsertionContext iFacts = mock(JobInsertionContext.class); + when(iFacts.getNewVehicle()).thenReturn(vehicle); + + TourActivity prevAct = getTourActivity(.0, firstActDuration, firstActDuration, location); + TourActivity newAct = getTourActivity(firstActDuration, firstActDuration + fixedCostAtSameLocation, newActivityDuration, location); + End end = new End(depot, firstActDuration, firstActDuration + fixedCostAtSameLocation + travelTime); + + final VehicleDependentTimeWindowConstraints timeWindowConstraints = new VehicleDependentTimeWindowConstraints(mock(RouteAndActivityStateGetter.class), getTransportCosts(travelTime), getActivityCost(fixedCostAtSameLocation)); + + assertEquals(timeWindowConstraints.fulfilled(iFacts, prevAct, newAct, end, 5.0), HardActivityConstraint.ConstraintsStatus.FULFILLED); + } + + @Test + public void testSquashEndNoReturnToDepot () { + final double fixedCostAtSameLocation = random.nextDouble(), + travelTime = random.nextDouble(), + firstActDuration = 5.0, newActivityDuration = 4.0, + vehicleLatestArrival = firstActDuration + fixedCostAtSameLocation; + + Location location = Location.newInstance(random.nextDouble(), random.nextDouble()); + Location depot = Location.newInstance(random.nextDouble(), random.nextDouble()); + + Vehicle vehicle = mock(Vehicle.class); + when(vehicle.getLatestArrival()).thenReturn(vehicleLatestArrival); + when(vehicle.isReturnToDepot()).thenReturn(false); + when(vehicle.getEndLocation()).thenReturn(depot); + + JobInsertionContext iFacts = mock(JobInsertionContext.class); + when(iFacts.getNewVehicle()).thenReturn(vehicle); + + TourActivity prevAct = getTourActivity(.0, firstActDuration, firstActDuration, location); + TourActivity newAct = getTourActivity(firstActDuration, firstActDuration + fixedCostAtSameLocation, newActivityDuration, location); + End end = new End(depot, firstActDuration, firstActDuration + fixedCostAtSameLocation); + + final VehicleDependentTimeWindowConstraints timeWindowConstraints = new VehicleDependentTimeWindowConstraints(mock(RouteAndActivityStateGetter.class), getTransportCosts(travelTime), getActivityCost(fixedCostAtSameLocation)); + + assertEquals(timeWindowConstraints.fulfilled(iFacts, prevAct, newAct, end, 5.0), HardActivityConstraint.ConstraintsStatus.FULFILLED); + } + + private TourActivity getTourActivity(double start, double end, double activityDuration, Location location) { + TourActivity act = mock(DeliveryActivity.class); + when(act.getTheoreticalEarliestOperationStartTime()).thenReturn(start); + when(act.getTheoreticalLatestOperationStartTime()).thenReturn(end); + when(act.getOperationTime()).thenReturn(activityDuration); + when(act.getLocation()).thenReturn(location); + return act; + } + private VehicleRoutingActivityCosts getActivityCost(final double fixedCostAtSameLocation) { return new VehicleRoutingActivityCosts() { @Override From 501588d417504fd4270310fba1c48b67cc75486f Mon Sep 17 00:00:00 2001 From: kobyb Date: Sun, 4 Feb 2018 11:53:33 +0200 Subject: [PATCH 7/8] CR --- ...pdateVehicleDependentPracticalTimeWindows.java | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java index cdab7965..661d8282 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java @@ -26,23 +26,22 @@ import com.graphhopper.jsprit.core.problem.solution.route.VehicleRoute; import com.graphhopper.jsprit.core.problem.solution.route.activity.TourActivity; import com.graphhopper.jsprit.core.problem.vehicle.Vehicle; +import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.List; public class UpdateVehicleDependentPracticalTimeWindows implements RouteVisitor, StateUpdater { @Override public void visit(VehicleRoute route) { begin(route); + List activities = new ArrayList<>(); + activities.add(route.getStart()); + activities.addAll(route.getTourActivities().getActivities()); - for (int i = route.getTourActivities().getActivities().size() - 1; i >= 0; --i) { - - if (i > 0) { - visit(route.getTourActivities().getActivities().get(i), route.getTourActivities().getActivities().get(i - 1)); - } else { - visit(route.getTourActivities().getActivities().get(i), route.getStart()); - } - } + for (int i = activities.size() - 1; i > 0; --i) + visit(activities.get(i), activities.get(i - 1)); finish(); } From af7d13fc0b7c5938c8b2c71e052050b20791da6f Mon Sep 17 00:00:00 2001 From: Kandel Irina Date: Sun, 4 Feb 2018 11:55:51 +0200 Subject: [PATCH 8/8] remove changes --- .../core/algorithm/state/UpdatePracticalTimeWindows.java | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdatePracticalTimeWindows.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdatePracticalTimeWindows.java index 29204573..a6ee4abf 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdatePracticalTimeWindows.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/state/UpdatePracticalTimeWindows.java @@ -56,14 +56,9 @@ class UpdatePracticalTimeWindows implements ReverseActivityVisitor, StateUpdater prevAct = route.getEnd(); } - @Override public void visit(TourActivity activity) { - double potentialLatestArrivalTimeAtCurrAct = - latestArrTimeAtPrevAct - - transportCosts.getBackwardTransportTime(activity.getLocation(), prevAct.getLocation(), latestArrTimeAtPrevAct, route.getDriver(), route.getVehicle()) - - activityCosts.getActivityDuration(activity, prevAct, latestArrTimeAtPrevAct,route.getDriver(),route.getVehicle()); - + double potentialLatestArrivalTimeAtCurrAct = latestArrTimeAtPrevAct - transportCosts.getBackwardTransportTime(activity.getLocation(), prevAct.getLocation(), latestArrTimeAtPrevAct, route.getDriver(), route.getVehicle()) - activityCosts.getActivityDuration(prevAct, activity,latestArrTimeAtPrevAct,route.getDriver(),route.getVehicle()); double latestArrivalTime = Math.min(activity.getTheoreticalLatestOperationStartTime(), potentialLatestArrivalTimeAtCurrAct); states.putInternalTypedActivityState(activity, InternalStates.LATEST_OPERATION_START_TIME, latestArrivalTime);