diff --git a/jsprit-core/src/main/java/algorithms/BackwardInTimeListeners.java b/jsprit-core/src/main/java/algorithms/BackwardInTimeListeners.java index effaa07a..2fcb5152 100644 --- a/jsprit-core/src/main/java/algorithms/BackwardInTimeListeners.java +++ b/jsprit-core/src/main/java/algorithms/BackwardInTimeListeners.java @@ -49,4 +49,8 @@ class BackwardInTimeListeners { for(BackwardInTimeListener l : listeners){ l.end(start, latestDepartureTime); } } + public boolean isEmpty() { + return listeners.isEmpty(); + } + } diff --git a/jsprit-core/src/main/java/algorithms/ForwardInTimeListeners.java b/jsprit-core/src/main/java/algorithms/ForwardInTimeListeners.java index 0f8b68d6..df093d1b 100644 --- a/jsprit-core/src/main/java/algorithms/ForwardInTimeListeners.java +++ b/jsprit-core/src/main/java/algorithms/ForwardInTimeListeners.java @@ -38,4 +38,8 @@ class ForwardInTimeListeners { for(ForwardInTimeListener l : listeners){ l.end(end, arrivalTime); } } + public boolean isEmpty() { + return listeners.isEmpty(); + } + } diff --git a/jsprit-core/src/main/java/algorithms/HardConstraints.java b/jsprit-core/src/main/java/algorithms/HardConstraints.java index c2eccf9f..656dbad1 100644 --- a/jsprit-core/src/main/java/algorithms/HardConstraints.java +++ b/jsprit-core/src/main/java/algorithms/HardConstraints.java @@ -28,7 +28,7 @@ class HardConstraints { } - static class HardRouteLevelConstraintAccumulator implements HardRouteLevelConstraint { + static class HardRouteLevelConstraintManager implements HardRouteLevelConstraint { private Collection hardConstraints = new ArrayList(); @@ -50,7 +50,7 @@ class HardConstraints { - static class HardActivityLevelConstraintAccumulator implements HardActivityLevelConstraint { + static class HardActivityLevelConstraintManager implements HardActivityLevelConstraint { private Collection hardConstraints = new ArrayList(); diff --git a/jsprit-core/src/main/java/algorithms/InsertionFactory.java b/jsprit-core/src/main/java/algorithms/InsertionFactory.java index ed82df20..402d0e98 100644 --- a/jsprit-core/src/main/java/algorithms/InsertionFactory.java +++ b/jsprit-core/src/main/java/algorithms/InsertionFactory.java @@ -25,11 +25,10 @@ import java.util.List; import java.util.concurrent.ExecutorService; import org.apache.commons.configuration.HierarchicalConfiguration; -import org.apache.commons.configuration.XMLConfiguration; import org.apache.log4j.Logger; +import algorithms.StateUpdates.UpdateStates; import basics.VehicleRoutingProblem; -import basics.VehicleRoutingProblem.FleetComposition; import basics.algo.InsertionListener; import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener; diff --git a/jsprit-core/src/main/java/algorithms/IterateRouteBackwardInTime.java b/jsprit-core/src/main/java/algorithms/IterateRouteBackwardInTime.java index afafcde2..925b3322 100644 --- a/jsprit-core/src/main/java/algorithms/IterateRouteBackwardInTime.java +++ b/jsprit-core/src/main/java/algorithms/IterateRouteBackwardInTime.java @@ -46,6 +46,7 @@ class IterateRouteBackwardInTime implements VehicleRouteUpdater{ * */ public void iterate(VehicleRoute vehicleRoute) { + if(listeners.isEmpty()) return; listeners.start(vehicleRoute, vehicleRoute.getEnd(), vehicleRoute.getEnd().getTheoreticalLatestOperationStartTime()); Iterator reverseActIter = vehicleRoute.getTourActivities().reverseActivityIterator(); diff --git a/jsprit-core/src/main/java/algorithms/IterateRouteForwardInTime.java b/jsprit-core/src/main/java/algorithms/IterateRouteForwardInTime.java index 868a84d7..62c6062d 100644 --- a/jsprit-core/src/main/java/algorithms/IterateRouteForwardInTime.java +++ b/jsprit-core/src/main/java/algorithms/IterateRouteForwardInTime.java @@ -48,6 +48,7 @@ class IterateRouteForwardInTime implements VehicleRouteUpdater{ * */ public void iterate(VehicleRoute vehicleRoute) { + if(listeners.isEmpty()) return; listeners.start(vehicleRoute, vehicleRoute.getStart(), vehicleRoute.getStart().getEndTime()); Vehicle vehicle = vehicleRoute.getVehicle(); diff --git a/jsprit-core/src/main/java/algorithms/StateUpdates.java b/jsprit-core/src/main/java/algorithms/StateUpdates.java new file mode 100644 index 00000000..9c7d4054 --- /dev/null +++ b/jsprit-core/src/main/java/algorithms/StateUpdates.java @@ -0,0 +1,576 @@ +package algorithms; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.apache.log4j.Logger; + +import algorithms.BackwardInTimeListeners.BackwardInTimeListener; +import algorithms.ForwardInTimeListeners.ForwardInTimeListener; +import algorithms.RuinStrategy.RuinListener; +import algorithms.StateManager.StateImpl; +import basics.Job; +import basics.Service; +import basics.VehicleRoutingProblem; +import basics.VehicleRoutingProblemSolution; +import basics.algo.InsertionEndsListener; +import basics.algo.InsertionStartsListener; +import basics.algo.IterationEndsListener; +import basics.algo.IterationStartsListener; +import basics.algo.JobInsertedListener; +import basics.algo.VehicleRoutingAlgorithmListener; +import basics.costs.ForwardTransportCost; +import basics.costs.VehicleRoutingActivityCosts; +import basics.costs.VehicleRoutingTransportCosts; +import basics.route.DeliveryActivity; +import basics.route.End; +import basics.route.PickupActivity; +import basics.route.Start; +import basics.route.TourActivity; +import basics.route.VehicleRoute; + +class StateUpdates { + + static class VRAListenersManager implements IterationStartsListener, IterationEndsListener, InsertionStartsListener, InsertionEndsListener, JobInsertedListener, RuinListener{ + + private Map,Collection> listeners = new HashMap,Collection>(); + + public void addListener(VehicleRoutingAlgorithmListener vraListener){ + if(!listeners.containsKey(vraListener.getClass())){ + listeners.put(vraListener.getClass(), new ArrayList()); + } + listeners.get(vraListener.getClass()).add(vraListener); + } + + @Override + public void ruinStarts(Collection routes) { + if(listeners.containsKey(RuinListener.class)){ + for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){ + ((RuinListener)l).ruinStarts(routes); + } + } + } + + @Override + public void ruinEnds(Collection routes,Collection unassignedJobs) { + if(listeners.containsKey(RuinListener.class)){ + for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){ + ((RuinListener)l).ruinEnds(routes,unassignedJobs); + } + } + } + + @Override + public void removed(Job job, VehicleRoute fromRoute) { + if(listeners.containsKey(RuinListener.class)){ + for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){ + ((RuinListener)l).removed(job, fromRoute); + } + } + } + + @Override + public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { + if(listeners.containsKey(JobInsertedListener.class)){ + for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){ + ((JobInsertedListener)l).informJobInserted(job2insert, inRoute, additionalCosts, additionalTime); + } + } + + } + + @Override + public void informInsertionEnds(Collection vehicleRoutes) { +// if(listeners.containsKey(JobInsertedListener.class)){ +// for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){ +// ((JobInsertedListener)l).informJobInserted(job2insert, inRoute, additionalCosts, additionalTime); +// } +// } + } + + @Override + public void informInsertionStarts(Collection vehicleRoutes,Collection unassignedJobs) { + // TODO Auto-generated method stub + + } + + @Override + public void informIterationEnds(int i, VehicleRoutingProblem problem,Collection solutions) { + // TODO Auto-generated method stub + + } + + @Override + public void informIterationStarts(int i, VehicleRoutingProblem problem,Collection solutions) { + // TODO Auto-generated method stub + + } + + } + + static class UpdateCostsAtRouteLevel implements JobInsertedListener, InsertionStartsListener, InsertionEndsListener{ + + private StateManagerImpl states; + + private VehicleRoutingTransportCosts tpCosts; + + private VehicleRoutingActivityCosts actCosts; + + public UpdateCostsAtRouteLevel(StateManagerImpl states, VehicleRoutingTransportCosts tpCosts, VehicleRoutingActivityCosts actCosts) { + super(); + this.states = states; + this.tpCosts = tpCosts; + this.actCosts = actCosts; + } + + @Override + public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { +// inRoute.getVehicleRouteCostCalculator().addTransportCost(additionalCosts); + double oldCosts = states.getRouteState(inRoute, StateTypes.COSTS).toDouble(); + oldCosts += additionalCosts; + states.putRouteState(inRoute, StateTypes.COSTS, new StateImpl(oldCosts)); + } + + @Override + public void informInsertionStarts(Collection vehicleRoutes, Collection unassignedJobs) { + IterateRouteForwardInTime forwardInTime = new IterateRouteForwardInTime(tpCosts); + forwardInTime.addListener(new UpdateCostsAtAllLevels(actCosts, tpCosts, states)); + for(VehicleRoute route : vehicleRoutes){ + forwardInTime.iterate(route); + } + + } + + @Override + public void informInsertionEnds(Collection vehicleRoutes) { + +// IterateRouteForwardInTime forwardInTime = new IterateRouteForwardInTime(tpCosts); +// forwardInTime.addListener(new UpdateCostsAtAllLevels(actCosts, tpCosts, states)); + for(VehicleRoute route : vehicleRoutes){ + if(route.isEmpty()) continue; + route.getVehicleRouteCostCalculator().reset(); + route.getVehicleRouteCostCalculator().addOtherCost(states.getRouteState(route, StateTypes.COSTS).toDouble()); + route.getVehicleRouteCostCalculator().price(route.getVehicle()); +// forwardInTime.iterate(route); + } + + } + + } + + static class UpdateActivityTimes implements ForwardInTimeListener{ + + private Logger log = Logger.getLogger(UpdateActivityTimes.class); + + @Override + public void start(VehicleRoute route, Start start, double departureTime) { + start.setEndTime(departureTime); + } + + @Override + public void nextActivity(TourActivity act, double arrTime, double endTime) { + act.setArrTime(arrTime); + act.setEndTime(endTime); + } + + @Override + public void end(End end, double arrivalTime) { + end.setArrTime(arrivalTime); + } + + } + + static class UpdateCostsAtAllLevels implements ForwardInTimeListener{ + + private static Logger log = Logger.getLogger(UpdateCostsAtAllLevels.class); + + private VehicleRoutingActivityCosts activityCost; + + private ForwardTransportCost transportCost; + + private StateManagerImpl states; + + private double totalOperationCost = 0.0; + + private VehicleRoute vehicleRoute = null; + + private TourActivity prevAct = null; + + private double startTimeAtPrevAct = 0.0; + + public UpdateCostsAtAllLevels(VehicleRoutingActivityCosts activityCost, ForwardTransportCost transportCost, StateManagerImpl states) { + super(); + this.activityCost = activityCost; + this.transportCost = transportCost; + this.states = states; + } + + @Override + public void start(VehicleRoute route, Start start, double departureTime) { + vehicleRoute = route; + vehicleRoute.getVehicleRouteCostCalculator().reset(); + prevAct = start; + startTimeAtPrevAct = departureTime; +// log.info(start + " depTime=" + departureTime); + } + + @Override + public void nextActivity(TourActivity act, double arrTime, double endTime) { +// log.info(act + " job " + ((JobActivity)act).getJob().getId() + " arrTime=" + arrTime + " endTime=" + endTime); + double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), act.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle()); + double actCost = activityCost.getActivityCost(act, arrTime, vehicleRoute.getDriver(), vehicleRoute.getVehicle()); + + vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost); + vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost); + + if(transportCost > 10000 || actCost > 100000){ + throw new IllegalStateException("aaaääähh"); + } + + totalOperationCost += transportCost; + totalOperationCost += actCost; + + states.putActivityState(act, StateTypes.COSTS, new StateImpl(totalOperationCost)); + + prevAct = act; + startTimeAtPrevAct = endTime; + } + + @Override + public void end(End end, double arrivalTime) { +// log.info(end + " arrTime=" + arrivalTime); + double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), end.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle()); + double actCost = activityCost.getActivityCost(end, arrivalTime, vehicleRoute.getDriver(), vehicleRoute.getVehicle()); + + vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost); + vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost); + + if(transportCost > 10000 || actCost > 100000){ + throw new IllegalStateException("aaaääähh"); + } + + totalOperationCost += transportCost; + totalOperationCost += actCost; + + states.putRouteState(vehicleRoute, StateTypes.COSTS, new StateImpl(totalOperationCost)); + + //this is rather strange and likely to change + vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getDriver()); + vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getVehicle()); + vehicleRoute.getVehicleRouteCostCalculator().finish(); + + startTimeAtPrevAct = 0.0; + prevAct = null; + vehicleRoute = null; + totalOperationCost = 0.0; + } + + } + + static class UpdateEarliestStartTimeWindowAtActLocations implements ForwardInTimeListener{ + + private StateManagerImpl states; + + public UpdateEarliestStartTimeWindowAtActLocations(StateManagerImpl states) { + super(); + this.states = states; + } + + @Override + public void start(VehicleRoute route, Start start, double departureTime) {} + + @Override + public void nextActivity(TourActivity act, double arrTime, double endTime) { + states.putActivityState(act, StateTypes.EARLIEST_OPERATION_START_TIME, new StateImpl(Math.max(arrTime, act.getTheoreticalEarliestOperationStartTime()))); + } + + @Override + public void end(End end, double arrivalTime) {} + + } + + static class UpdateLatestOperationStartTimeAtActLocations implements BackwardInTimeListener{ + + private static Logger log = Logger.getLogger(UpdateLatestOperationStartTimeAtActLocations.class); + + private StateManagerImpl states; + + public UpdateLatestOperationStartTimeAtActLocations(StateManagerImpl states) { + super(); + this.states = states; + } + + @Override + public void start(VehicleRoute route, End end, double latestArrivalTime) {} + + @Override + public void prevActivity(TourActivity act,double latestDepartureTime, double latestOperationStartTime) { +// log.info(act + " jobId=" + ((JobActivity)act).getJob().getId() + " " + latestOperationStartTime); + states.putActivityState(act, StateTypes.LATEST_OPERATION_START_TIME, new StateImpl(latestOperationStartTime)); + } + + @Override + public void end(Start start, double latestDepartureTime) {} + + + + } + + static class UpdateLoadAtAllLevels implements ForwardInTimeListener{ + + private double load = 0.0; + + private StateManagerImpl states; + + private VehicleRoute vehicleRoute; + + public UpdateLoadAtAllLevels(StateManagerImpl states) { + super(); + this.states = states; + } + + @Override + public void start(VehicleRoute route, Start start, double departureTime) { vehicleRoute = route; } + + @Override + public void nextActivity(TourActivity act, double arrTime, double endTime) { + load += (double)act.getCapacityDemand(); + states.putActivityState(act, StateTypes.LOAD, new StateImpl(load)); + } + + @Override + public void end(End end, double arrivalTime) { + states.putRouteState(vehicleRoute, StateTypes.LOAD, new StateImpl(load)); + load=0; + vehicleRoute = null; + } + + } + + static class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsListener{ + + private StateManagerImpl states; + + public UpdateLoadAtRouteLevel(StateManagerImpl states) { + super(); + this.states = states; + } + + @Override + public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { + if(!(job2insert instanceof Service)){ + return; + } + double oldLoad = states.getRouteState(inRoute, StateTypes.LOAD).toDouble(); + states.putRouteState(inRoute, StateTypes.LOAD, new StateImpl(oldLoad + job2insert.getCapacityDemand())); + } + + @Override + public void informInsertionStarts(Collection vehicleRoutes, Collection unassignedJobs) { + for(VehicleRoute route : vehicleRoutes){ + int load = 0; + for(Job j : route.getTourActivities().getJobs()){ + load += j.getCapacityDemand(); + } + states.putRouteState(route, StateTypes.LOAD, new StateImpl(load)); + } + + } + + } + + static class UpdateStates implements JobInsertedListener, RuinListener{ + + private IterateRouteForwardInTime iterateForward; + + private IterateRouteBackwardInTime iterateBackward; + + public UpdateStates(StateManagerImpl states, VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts activityCosts) { + + iterateForward = new IterateRouteForwardInTime(routingCosts); + iterateForward.addListener(new UpdateActivityTimes()); + iterateForward.addListener(new UpdateCostsAtAllLevels(activityCosts, routingCosts, states)); + iterateForward.addListener(new UpdateLoadAtAllLevels(states)); +// iterateForward.addListener(new UpdateEarliestStartTimeWindowAtActLocations(states)); + + iterateBackward = new IterateRouteBackwardInTime(routingCosts); + iterateBackward.addListener(new UpdateLatestOperationStartTimeAtActLocations(states)); + } + + public void update(VehicleRoute route){ + iterateForward.iterate(route); + iterateBackward.iterate(route); + } + + @Override + public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { + iterateForward.iterate(inRoute); + iterateBackward.iterate(inRoute); + } + + @Override + public void ruinStarts(Collection routes) {} + + @Override + public void ruinEnds(Collection routes,Collection unassignedJobs) { + for(VehicleRoute route : routes) { + iterateForward.iterate(route); + iterateBackward.iterate(route); + } + } + + @Override + public void removed(Job job, VehicleRoute fromRoute) {} + + } + + static class UpdateFuturePickupsAtActivityLevel implements BackwardInTimeListener { + private StateManagerImpl stateManager; + private int futurePicks = 0; + private VehicleRoute route; + + public UpdateFuturePickupsAtActivityLevel(StateManagerImpl stateManager) { + super(); + this.stateManager = stateManager; + } + + @Override + public void start(VehicleRoute route, End end, double latestArrivalTime) { + this.route = route; + } + + @Override + public void prevActivity(TourActivity act, double latestDepartureTime, double latestOperationStartTime) { + stateManager.putActivityState(act, StateTypes.FUTURE_PICKS, new StateImpl(futurePicks)); + if(act instanceof PickupActivity){ + futurePicks += act.getCapacityDemand(); + } + assert futurePicks <= route.getVehicle().getCapacity() : "sum of pickups must not be > vehicleCap"; + assert futurePicks >= 0 : "sum of pickups must not < 0"; + } + + @Override + public void end(Start start, double latestDepartureTime) { + futurePicks = 0; + route = null; + } + } + + static class UpdateOccuredDeliveriesAtActivityLevel implements ForwardInTimeListener { + private StateManagerImpl stateManager; + private int deliveries = 0; + private VehicleRoute route; + + public UpdateOccuredDeliveriesAtActivityLevel(StateManagerImpl stateManager) { + super(); + this.stateManager = stateManager; + } + + @Override + public void start(VehicleRoute route, Start start, double departureTime) { + this.route = route; + } + + @Override + public void nextActivity(TourActivity act, double arrTime, double endTime) { + if(act instanceof DeliveryActivity){ + deliveries += Math.abs(act.getCapacityDemand()); + } + stateManager.putActivityState(act, StateTypes.PAST_DELIVERIES, new StateImpl(deliveries)); + assert deliveries >= 0 : "deliveries < 0"; + assert deliveries <= route.getVehicle().getCapacity() : "deliveries > vehicleCap"; + } + + @Override + public void end(End end, double arrivalTime) { + deliveries = 0; + route = null; + } + } + + /** + * Updates load at activity level. Note that this assumed that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT. + * If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot. + * + * @author stefan + * + */ + static class UpdateLoadAtActivityLevel implements ForwardInTimeListener { + private StateManagerImpl stateManager; + private int currentLoad = 0; + private VehicleRoute route; + + public UpdateLoadAtActivityLevel(StateManagerImpl stateManager) { + super(); + this.stateManager = stateManager; + } + + @Override + public void start(VehicleRoute route, Start start, double departureTime) { + currentLoad = (int) stateManager.getRouteState(route, StateTypes.LOAD_AT_DEPOT).toDouble(); + this.route = route; + } + + @Override + public void nextActivity(TourActivity act, double arrTime, double endTime) { + currentLoad += act.getCapacityDemand(); + stateManager.putActivityState(act, StateTypes.LOAD, new StateImpl(currentLoad)); + assert currentLoad <= route.getVehicle().getCapacity() : "currentLoad at activity must not be > vehicleCapacity"; + assert currentLoad >= 0 : "currentLoad at act must not be < 0"; + } + + @Override + public void end(End end, double arrivalTime) { + currentLoad = 0; + } + } + + static class ResetStateManager implements IterationStartsListener { + + private StateManagerImpl stateManager; + + public ResetStateManager(StateManagerImpl stateManager) { + super(); + this.stateManager = stateManager; + } + + @Override + public void informIterationStarts(int i, VehicleRoutingProblem problem, Collection solutions) { + stateManager.clear(); + } + } + + static class WalkThroughAndUpdateRoutesOnceTheyChanged implements InsertionStartsListener, JobInsertedListener { + + private IterateRouteForwardInTime forwardInTimeIterator; + + private IterateRouteBackwardInTime backwardInTimeIterator; + + public WalkThroughAndUpdateRoutesOnceTheyChanged(VehicleRoutingTransportCosts routingCosts) { + forwardInTimeIterator = new IterateRouteForwardInTime(routingCosts); + backwardInTimeIterator = new IterateRouteBackwardInTime(routingCosts); + } + + void addListener(ForwardInTimeListener l){ + forwardInTimeIterator.addListener(l); + } + + void addListener(BackwardInTimeListener l){ + backwardInTimeIterator.addListener(l); + } + + @Override + public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { + + } + + @Override + public void informInsertionStarts(Collection vehicleRoutes, Collection unassignedJobs) { + // TODO Auto-generated method stub + + } + + } +} diff --git a/jsprit-core/src/main/java/algorithms/UdateCostsAtRouteLevel.java b/jsprit-core/src/main/java/algorithms/UdateCostsAtRouteLevel.java deleted file mode 100644 index b058549f..00000000 --- a/jsprit-core/src/main/java/algorithms/UdateCostsAtRouteLevel.java +++ /dev/null @@ -1,62 +0,0 @@ -package algorithms; - -import java.util.Collection; - -import algorithms.StateManager.StateImpl; -import basics.Job; -import basics.algo.InsertionEndsListener; -import basics.algo.InsertionStartsListener; -import basics.algo.JobInsertedListener; -import basics.costs.VehicleRoutingActivityCosts; -import basics.costs.VehicleRoutingTransportCosts; -import basics.route.VehicleRoute; - -class UdateCostsAtRouteLevel implements JobInsertedListener, InsertionStartsListener, InsertionEndsListener{ - - private StateManagerImpl states; - - private VehicleRoutingTransportCosts tpCosts; - - private VehicleRoutingActivityCosts actCosts; - - public UdateCostsAtRouteLevel(StateManagerImpl states, VehicleRoutingTransportCosts tpCosts, VehicleRoutingActivityCosts actCosts) { - super(); - this.states = states; - this.tpCosts = tpCosts; - this.actCosts = actCosts; - } - - @Override - public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { -// inRoute.getVehicleRouteCostCalculator().addTransportCost(additionalCosts); - double oldCosts = states.getRouteState(inRoute, StateTypes.COSTS).toDouble(); - oldCosts += additionalCosts; - states.putRouteState(inRoute, StateTypes.COSTS, new StateImpl(oldCosts)); - } - - @Override - public void informInsertionStarts(Collection vehicleRoutes, Collection unassignedJobs) { - IterateRouteForwardInTime forwardInTime = new IterateRouteForwardInTime(tpCosts); - forwardInTime.addListener(new UpdateCostsAtAllLevels(actCosts, tpCosts, states)); - for(VehicleRoute route : vehicleRoutes){ - forwardInTime.iterate(route); - } - - } - - @Override - public void informInsertionEnds(Collection vehicleRoutes) { - -// IterateRouteForwardInTime forwardInTime = new IterateRouteForwardInTime(tpCosts); -// forwardInTime.addListener(new UpdateCostsAtAllLevels(actCosts, tpCosts, states)); - for(VehicleRoute route : vehicleRoutes){ - if(route.isEmpty()) continue; - route.getVehicleRouteCostCalculator().reset(); - route.getVehicleRouteCostCalculator().addOtherCost(states.getRouteState(route, StateTypes.COSTS).toDouble()); - route.getVehicleRouteCostCalculator().price(route.getVehicle()); -// forwardInTime.iterate(route); - } - - } - -} diff --git a/jsprit-core/src/main/java/algorithms/UpdateActivityTimes.java b/jsprit-core/src/main/java/algorithms/UpdateActivityTimes.java deleted file mode 100644 index 308739c6..00000000 --- a/jsprit-core/src/main/java/algorithms/UpdateActivityTimes.java +++ /dev/null @@ -1,31 +0,0 @@ -package algorithms; - -import org.apache.log4j.Logger; - -import algorithms.ForwardInTimeListeners.ForwardInTimeListener; -import basics.route.End; -import basics.route.Start; -import basics.route.TourActivity; -import basics.route.VehicleRoute; - -class UpdateActivityTimes implements ForwardInTimeListener{ - - private Logger log = Logger.getLogger(UpdateActivityTimes.class); - - @Override - public void start(VehicleRoute route, Start start, double departureTime) { - start.setEndTime(departureTime); - } - - @Override - public void nextActivity(TourActivity act, double arrTime, double endTime) { - act.setArrTime(arrTime); - act.setEndTime(endTime); - } - - @Override - public void end(End end, double arrivalTime) { - end.setArrTime(arrivalTime); - } - -} diff --git a/jsprit-core/src/main/java/algorithms/UpdateCostsAtAllLevels.java b/jsprit-core/src/main/java/algorithms/UpdateCostsAtAllLevels.java deleted file mode 100644 index b7852a83..00000000 --- a/jsprit-core/src/main/java/algorithms/UpdateCostsAtAllLevels.java +++ /dev/null @@ -1,100 +0,0 @@ -package algorithms; - -import org.apache.log4j.Logger; - -import algorithms.ForwardInTimeListeners.ForwardInTimeListener; -import algorithms.StateManager.StateImpl; -import basics.costs.ForwardTransportCost; -import basics.costs.VehicleRoutingActivityCosts; -import basics.route.End; -import basics.route.Start; -import basics.route.TourActivity; -import basics.route.TourActivity.JobActivity; -import basics.route.VehicleRoute; - -class UpdateCostsAtAllLevels implements ForwardInTimeListener{ - - private static Logger log = Logger.getLogger(UpdateCostsAtAllLevels.class); - - private VehicleRoutingActivityCosts activityCost; - - private ForwardTransportCost transportCost; - - private StateManagerImpl states; - - private double totalOperationCost = 0.0; - - private VehicleRoute vehicleRoute = null; - - private TourActivity prevAct = null; - - private double startTimeAtPrevAct = 0.0; - - public UpdateCostsAtAllLevels(VehicleRoutingActivityCosts activityCost, ForwardTransportCost transportCost, StateManagerImpl states) { - super(); - this.activityCost = activityCost; - this.transportCost = transportCost; - this.states = states; - } - - @Override - public void start(VehicleRoute route, Start start, double departureTime) { - vehicleRoute = route; - vehicleRoute.getVehicleRouteCostCalculator().reset(); - prevAct = start; - startTimeAtPrevAct = departureTime; -// log.info(start + " depTime=" + departureTime); - } - - @Override - public void nextActivity(TourActivity act, double arrTime, double endTime) { -// log.info(act + " job " + ((JobActivity)act).getJob().getId() + " arrTime=" + arrTime + " endTime=" + endTime); - double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), act.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle()); - double actCost = activityCost.getActivityCost(act, arrTime, vehicleRoute.getDriver(), vehicleRoute.getVehicle()); - - vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost); - vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost); - - if(transportCost > 10000 || actCost > 100000){ - throw new IllegalStateException("aaaääähh"); - } - - totalOperationCost += transportCost; - totalOperationCost += actCost; - - states.putActivityState(act, StateTypes.COSTS, new StateImpl(totalOperationCost)); - - prevAct = act; - startTimeAtPrevAct = endTime; - } - - @Override - public void end(End end, double arrivalTime) { -// log.info(end + " arrTime=" + arrivalTime); - double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), end.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle()); - double actCost = activityCost.getActivityCost(end, arrivalTime, vehicleRoute.getDriver(), vehicleRoute.getVehicle()); - - vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost); - vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost); - - if(transportCost > 10000 || actCost > 100000){ - throw new IllegalStateException("aaaääähh"); - } - - totalOperationCost += transportCost; - totalOperationCost += actCost; - - states.putRouteState(vehicleRoute, StateTypes.COSTS, new StateImpl(totalOperationCost)); - - //this is rather strange and likely to change - vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getDriver()); - vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getVehicle()); - vehicleRoute.getVehicleRouteCostCalculator().finish(); - - startTimeAtPrevAct = 0.0; - prevAct = null; - vehicleRoute = null; - totalOperationCost = 0.0; - } - -} diff --git a/jsprit-core/src/main/java/algorithms/UpdateEarliestStartTimeWindowAtActLocations.java b/jsprit-core/src/main/java/algorithms/UpdateEarliestStartTimeWindowAtActLocations.java deleted file mode 100644 index 1fab69ef..00000000 --- a/jsprit-core/src/main/java/algorithms/UpdateEarliestStartTimeWindowAtActLocations.java +++ /dev/null @@ -1,30 +0,0 @@ -package algorithms; - -import algorithms.ForwardInTimeListeners.ForwardInTimeListener; -import algorithms.StateManager.StateImpl; -import basics.route.End; -import basics.route.Start; -import basics.route.TourActivity; -import basics.route.VehicleRoute; - -class UpdateEarliestStartTimeWindowAtActLocations implements ForwardInTimeListener{ - - private StateManagerImpl states; - - public UpdateEarliestStartTimeWindowAtActLocations(StateManagerImpl states) { - super(); - this.states = states; - } - - @Override - public void start(VehicleRoute route, Start start, double departureTime) {} - - @Override - public void nextActivity(TourActivity act, double arrTime, double endTime) { - states.putActivityState(act, StateTypes.EARLIEST_OPERATION_START_TIME, new StateImpl(Math.max(arrTime, act.getTheoreticalEarliestOperationStartTime()))); - } - - @Override - public void end(End end, double arrivalTime) {} - -} diff --git a/jsprit-core/src/main/java/algorithms/UpdateLatestOperationStartTimeAtActLocations.java b/jsprit-core/src/main/java/algorithms/UpdateLatestOperationStartTimeAtActLocations.java deleted file mode 100644 index 6607bd50..00000000 --- a/jsprit-core/src/main/java/algorithms/UpdateLatestOperationStartTimeAtActLocations.java +++ /dev/null @@ -1,38 +0,0 @@ -package algorithms; - -import org.apache.log4j.Logger; - -import algorithms.BackwardInTimeListeners.BackwardInTimeListener; -import algorithms.StateManager.StateImpl; -import basics.route.End; -import basics.route.Start; -import basics.route.TourActivity; -import basics.route.TourActivity.JobActivity; -import basics.route.VehicleRoute; - -class UpdateLatestOperationStartTimeAtActLocations implements BackwardInTimeListener{ - - private static Logger log = Logger.getLogger(UpdateLatestOperationStartTimeAtActLocations.class); - - private StateManagerImpl states; - - public UpdateLatestOperationStartTimeAtActLocations(StateManagerImpl states) { - super(); - this.states = states; - } - - @Override - public void start(VehicleRoute route, End end, double latestArrivalTime) {} - - @Override - public void prevActivity(TourActivity act,double latestDepartureTime, double latestOperationStartTime) { -// log.info(act + " jobId=" + ((JobActivity)act).getJob().getId() + " " + latestOperationStartTime); - states.putActivityState(act, StateTypes.LATEST_OPERATION_START_TIME, new StateImpl(latestOperationStartTime)); - } - - @Override - public void end(Start start, double latestDepartureTime) {} - - - -} diff --git a/jsprit-core/src/main/java/algorithms/UpdateLoadAtAllLevels.java b/jsprit-core/src/main/java/algorithms/UpdateLoadAtAllLevels.java deleted file mode 100644 index 5de4cdc2..00000000 --- a/jsprit-core/src/main/java/algorithms/UpdateLoadAtAllLevels.java +++ /dev/null @@ -1,45 +0,0 @@ -package algorithms; - -import algorithms.ForwardInTimeListeners.ForwardInTimeListener; -import algorithms.StateManager.StateImpl; -import basics.route.End; -import basics.route.Start; -import basics.route.TourActivity; -import basics.route.VehicleRoute; - -/** - * It does not update start and end activities. - * - * @author stefan - * - */ -class UpdateLoadAtAllLevels implements ForwardInTimeListener{ - - private double load = 0.0; - - private StateManagerImpl states; - - private VehicleRoute vehicleRoute; - - public UpdateLoadAtAllLevels(StateManagerImpl states) { - super(); - this.states = states; - } - - @Override - public void start(VehicleRoute route, Start start, double departureTime) { vehicleRoute = route; } - - @Override - public void nextActivity(TourActivity act, double arrTime, double endTime) { - load += (double)act.getCapacityDemand(); - states.putActivityState(act, StateTypes.LOAD, new StateImpl(load)); - } - - @Override - public void end(End end, double arrivalTime) { - states.putRouteState(vehicleRoute, StateTypes.LOAD, new StateImpl(load)); - load=0; - vehicleRoute = null; - } - -} diff --git a/jsprit-core/src/main/java/algorithms/UpdateLoadAtRouteLevel.java b/jsprit-core/src/main/java/algorithms/UpdateLoadAtRouteLevel.java deleted file mode 100644 index 5ed2adc1..00000000 --- a/jsprit-core/src/main/java/algorithms/UpdateLoadAtRouteLevel.java +++ /dev/null @@ -1,42 +0,0 @@ -package algorithms; - -import java.util.Collection; - -import algorithms.StateManager.StateImpl; -import basics.Job; -import basics.Service; -import basics.algo.InsertionStartsListener; -import basics.algo.JobInsertedListener; -import basics.route.VehicleRoute; - -class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsListener{ - - private StateManagerImpl states; - - public UpdateLoadAtRouteLevel(StateManagerImpl states) { - super(); - this.states = states; - } - - @Override - public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { - if(!(job2insert instanceof Service)){ - return; - } - double oldLoad = states.getRouteState(inRoute, StateTypes.LOAD).toDouble(); - states.putRouteState(inRoute, StateTypes.LOAD, new StateImpl(oldLoad + job2insert.getCapacityDemand())); - } - - @Override - public void informInsertionStarts(Collection vehicleRoutes, Collection unassignedJobs) { - for(VehicleRoute route : vehicleRoutes){ - int load = 0; - for(Job j : route.getTourActivities().getJobs()){ - load += j.getCapacityDemand(); - } - states.putRouteState(route, StateTypes.LOAD, new StateImpl(load)); - } - - } - -} diff --git a/jsprit-core/src/main/java/algorithms/UpdateStates.java b/jsprit-core/src/main/java/algorithms/UpdateStates.java deleted file mode 100644 index 0d61558d..00000000 --- a/jsprit-core/src/main/java/algorithms/UpdateStates.java +++ /dev/null @@ -1,55 +0,0 @@ -package algorithms; - -import java.util.Collection; - -import algorithms.RuinStrategy.RuinListener; -import basics.Job; -import basics.algo.JobInsertedListener; -import basics.costs.VehicleRoutingActivityCosts; -import basics.costs.VehicleRoutingTransportCosts; -import basics.route.VehicleRoute; - -class UpdateStates implements JobInsertedListener, RuinListener{ - - private IterateRouteForwardInTime iterateForward; - - private IterateRouteBackwardInTime iterateBackward; - - public UpdateStates(StateManagerImpl states, VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts activityCosts) { - - iterateForward = new IterateRouteForwardInTime(routingCosts); - iterateForward.addListener(new UpdateActivityTimes()); - iterateForward.addListener(new UpdateCostsAtAllLevels(activityCosts, routingCosts, states)); - iterateForward.addListener(new UpdateLoadAtAllLevels(states)); -// iterateForward.addListener(new UpdateEarliestStartTimeWindowAtActLocations(states)); - - iterateBackward = new IterateRouteBackwardInTime(routingCosts); - iterateBackward.addListener(new UpdateLatestOperationStartTimeAtActLocations(states)); - } - - public void update(VehicleRoute route){ - iterateForward.iterate(route); - iterateBackward.iterate(route); - } - - @Override - public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { - iterateForward.iterate(inRoute); - iterateBackward.iterate(inRoute); - } - - @Override - public void ruinStarts(Collection routes) {} - - @Override - public void ruinEnds(Collection routes,Collection unassignedJobs) { - for(VehicleRoute route : routes) { - iterateForward.iterate(route); - iterateBackward.iterate(route); - } - } - - @Override - public void removed(Job job, VehicleRoute fromRoute) {} - -} diff --git a/jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithms.java b/jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithms.java index 0f52a27c..ad9fa4aa 100644 --- a/jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithms.java +++ b/jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithms.java @@ -36,10 +36,10 @@ import org.apache.commons.configuration.XMLConfiguration; import org.apache.log4j.Logger; import util.RouteUtils; -import algorithms.RuinStrategy.RuinListener; -import algorithms.VehicleRoutingAlgorithms.TypedMap.InsertionStrategyKey; +import algorithms.StateUpdates.UpdateStates; import algorithms.VehicleRoutingAlgorithms.TypedMap.AbstractKey; import algorithms.VehicleRoutingAlgorithms.TypedMap.AcceptorKey; +import algorithms.VehicleRoutingAlgorithms.TypedMap.InsertionStrategyKey; import algorithms.VehicleRoutingAlgorithms.TypedMap.RuinStrategyKey; import algorithms.VehicleRoutingAlgorithms.TypedMap.SelectorKey; import algorithms.VehicleRoutingAlgorithms.TypedMap.StrategyModuleKey; @@ -71,7 +71,6 @@ import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener; import basics.algo.VehicleRoutingAlgorithmListeners.Priority; import basics.io.AlgorithmConfig; import basics.io.AlgorithmConfigXmlReader; -import basics.route.VehicleRoute; diff --git a/jsprit-core/src/main/java/basics/algo/SearchStrategyListener.java b/jsprit-core/src/main/java/basics/algo/SearchStrategyListener.java index b3aea8f3..a232003d 100644 --- a/jsprit-core/src/main/java/basics/algo/SearchStrategyListener.java +++ b/jsprit-core/src/main/java/basics/algo/SearchStrategyListener.java @@ -20,6 +20,6 @@ ******************************************************************************/ package basics.algo; -public class SearchStrategyListener { +public interface SearchStrategyListener extends VehicleRoutingAlgorithmListener{ } diff --git a/jsprit-core/src/main/java/basics/algo/SearchStrategyModuleListener.java b/jsprit-core/src/main/java/basics/algo/SearchStrategyModuleListener.java index 05d171e3..f216f197 100644 --- a/jsprit-core/src/main/java/basics/algo/SearchStrategyModuleListener.java +++ b/jsprit-core/src/main/java/basics/algo/SearchStrategyModuleListener.java @@ -20,6 +20,6 @@ ******************************************************************************/ package basics.algo; -public interface SearchStrategyModuleListener { +public interface SearchStrategyModuleListener extends VehicleRoutingAlgorithmListener{ } diff --git a/jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java b/jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java index 64928195..c1c510f5 100644 --- a/jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java +++ b/jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java @@ -1,6 +1,6 @@ package algorithms; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import java.util.Collection; @@ -9,6 +9,8 @@ import org.junit.Test; import util.Solutions; import algorithms.HardConstraints.HardActivityLevelConstraint; +import algorithms.StateUpdates.UpdateCostsAtRouteLevel; +import algorithms.StateUpdates.UpdateLoadAtRouteLevel; import algorithms.acceptors.AcceptNewIfBetterThanWorst; import algorithms.selectors.SelectBest; import basics.VehicleRoutingAlgorithm; @@ -76,7 +78,7 @@ public class BuildCVRPAlgoFromScratchTest { vra.getAlgorithmListeners().addListener(clearStateManager); vra.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager)); - vra.getSearchStrategyManager().addSearchStrategyModuleListener(new UdateCostsAtRouteLevel(stateManager, vrp.getTransportCosts(), vrp.getActivityCosts())); + vra.getSearchStrategyManager().addSearchStrategyModuleListener(new UpdateCostsAtRouteLevel(stateManager, vrp.getTransportCosts(), vrp.getActivityCosts())); vra.getSearchStrategyManager().addSearchStrategyModuleListener(new UpdateLoadAtRouteLevel(stateManager)); VehicleRoutingProblemSolution iniSolution = new CreateInitialSolution(bestInsertion).createInitialSolution(vrp); diff --git a/jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java b/jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java index 04fddd9d..fa3242d0 100644 --- a/jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java +++ b/jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java @@ -9,8 +9,12 @@ import org.junit.Test; import util.Solutions; import algorithms.BackwardInTimeListeners.BackwardInTimeListener; import algorithms.ForwardInTimeListeners.ForwardInTimeListener; -import algorithms.HardConstraints.HardActivityLevelConstraintAccumulator; +import algorithms.HardConstraints.HardActivityLevelConstraintManager; import algorithms.StateManager.StateImpl; +import algorithms.StateUpdates.UpdateActivityTimes; +import algorithms.StateUpdates.UpdateCostsAtAllLevels; +import algorithms.StateUpdates.UpdateEarliestStartTimeWindowAtActLocations; +import algorithms.StateUpdates.UpdateLatestOperationStartTimeAtActLocations; import algorithms.acceptors.AcceptNewIfBetterThanWorst; import algorithms.selectors.SelectBest; import basics.Delivery; @@ -28,6 +32,7 @@ import basics.io.VrpXMLReader; import basics.io.VrpXMLWriter; import basics.route.DeliveryActivity; import basics.route.End; +import basics.route.PickupActivity; import basics.route.Start; import basics.route.TourActivity; import basics.route.VehicleRoute; @@ -49,7 +54,7 @@ public class BuildPDVRPAlgoFromScratchTest { final StateManagerImpl stateManager = new StateManagerImpl(); - HardActivityLevelConstraintAccumulator actLevelConstraintAccumulator = new HardActivityLevelConstraintAccumulator(); + HardActivityLevelConstraintManager actLevelConstraintAccumulator = new HardActivityLevelConstraintManager(); actLevelConstraintAccumulator.addConstraint(new HardConstraints.HardPickupAndDeliveryConstraint(stateManager)); actLevelConstraintAccumulator.addConstraint(new HardConstraints.HardTimeWindowConstraint(stateManager, vrp.getTransportCosts())); @@ -80,16 +85,8 @@ public class BuildPDVRPAlgoFromScratchTest { vra = new VehicleRoutingAlgorithm(vrp, strategyManager); - //listeners - IterationStartsListener clearStateManager = new IterationStartsListener() { - - @Override - public void informIterationStarts(int i, VehicleRoutingProblem problem, Collection solutions) { - stateManager.clear(); - } - - }; - vra.getAlgorithmListeners().addListener(clearStateManager); + + vra.getAlgorithmListeners().addListener(new StateUpdates.ResetStateManager(stateManager)); final IterateRouteForwardInTime iterateForward = new IterateRouteForwardInTime(vrp.getTransportCosts()); @@ -97,74 +94,12 @@ public class BuildPDVRPAlgoFromScratchTest { iterateForward.addListener(new UpdateEarliestStartTimeWindowAtActLocations(stateManager)); iterateForward.addListener(new UpdateCostsAtAllLevels(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager)); -// iterateForward.addListener(new UpdateLoadAtAllLevels(stateManager)); + iterateForward.addListener(new StateUpdates.UpdateOccuredDeliveriesAtActivityLevel(stateManager)); + iterateForward.addListener(new StateUpdates.UpdateLoadAtActivityLevel(stateManager)); - iterateForward.addListener(new ForwardInTimeListener() { - - private int currentLoad = 0; - private int deliveries = 0; - private VehicleRoute route; - - @Override - public void start(VehicleRoute route, Start start, double departureTime) { -// log.info("iterate forward"); - currentLoad = (int) stateManager.getRouteState(route, StateTypes.LOAD_AT_DEPOT).toDouble(); - this.route = route; -// log.info("currentLoad="+currentLoad); - } - - @Override - public void nextActivity(TourActivity act, double arrTime, double endTime) { -// log.info("nextAct="+act.getClass().toString()+ " capDemand=" + act.getCapacityDemand() + " currentLoad="+currentLoad); - currentLoad += act.getCapacityDemand(); - if(act instanceof DeliveryActivity){ - deliveries += Math.abs(act.getCapacityDemand()); - } - stateManager.putActivityState(act, StateTypes.LOAD, new StateImpl(currentLoad)); - stateManager.putActivityState(act, StateTypes.PAST_DELIVERIES, new StateImpl(deliveries)); - if(currentLoad < 0) throw new IllegalStateException("currentload < 0"); - if(currentLoad > route.getVehicle().getCapacity()){ - throw new IllegalStateException("currentload="+currentLoad+" wich is > " + route.getVehicle().getCapacity()); - } - - } - - @Override - public void end(End end, double arrivalTime) { -// log.info("currentLoad="+currentLoad); -// stateManager.putRouteState(route, StateTypes.LOAD, new StateImpl(currentLoad)); - currentLoad = 0; - deliveries = 0; - route = null; - } - }); -// final IterateRouteBackwardInTime iterateBackward = new IterateRouteBackwardInTime(vrp.getTransportCosts()); iterateBackward.addListener(new UpdateLatestOperationStartTimeAtActLocations(stateManager)); - iterateBackward.addListener(new BackwardInTimeListener() { - - int futurePicks = 0; - @Override - public void start(VehicleRoute route, End end, double latestArrivalTime) { - - - } - - @Override - public void prevActivity(TourActivity act, double latestDepartureTime, double latestOperationStartTime) { - stateManager.putActivityState(act, StateTypes.FUTURE_PICKS, new StateImpl(futurePicks)); - if(act.getCapacityDemand() > 0){ - futurePicks += act.getCapacityDemand(); - } - - } - - @Override - public void end(Start start, double latestDepartureTime) { - futurePicks = 0; - - } - }); + iterateBackward.addListener(new StateUpdates.UpdateFuturePickupsAtActivityLevel(stateManager)); InsertionStartsListener loadVehicleInDepot = new InsertionStartsListener() { @@ -192,9 +127,6 @@ public class BuildPDVRPAlgoFromScratchTest { }; vra.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager)); - -// vra.getSearchStrategyManager().addSearchStrategyModuleListener(loadVehicleInDepot); - JobInsertedListener updateLoadAfterJobHasBeenInserted = new JobInsertedListener() { @@ -212,14 +144,11 @@ public class BuildPDVRPAlgoFromScratchTest { // log.info("loadAtEnd="+loadAtEnd); stateManager.putRouteState(inRoute, StateTypes.LOAD, new StateImpl(loadAtEnd + job2insert.getCapacityDemand())); } - iterateForward.iterate(inRoute); iterateBackward.iterate(inRoute); } }; - -// vra.getSearchStrategyManager().addSearchStrategyModuleListener(updateLoadAfterJobHasBeenInserted); - + bestInsertion.addListener(loadVehicleInDepot); bestInsertion.addListener(updateLoadAfterJobHasBeenInserted); diff --git a/jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java b/jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java index e43ec161..a82b670c 100644 --- a/jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java +++ b/jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java @@ -33,6 +33,7 @@ import org.junit.Test; import util.Coordinate; import util.ManhattanDistanceCalculator; import util.RouteUtils; +import algorithms.StateUpdates.UpdateStates; import basics.Job; import basics.Service; import basics.VehicleRoutingProblem; diff --git a/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java b/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java index 3ac94346..ebd5a30b 100644 --- a/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java +++ b/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java @@ -32,17 +32,18 @@ import org.apache.log4j.Logger; import org.junit.Before; import org.junit.Test; +import algorithms.StateUpdates.UpdateStates; import basics.Job; import basics.Service; import basics.costs.VehicleRoutingTransportCosts; import basics.route.DriverImpl; +import basics.route.DriverImpl.NoDriver; import basics.route.ServiceActivity; import basics.route.TimeWindow; import basics.route.TourActivities; import basics.route.TourActivity; import basics.route.Vehicle; import basics.route.VehicleRoute; -import basics.route.DriverImpl.NoDriver; diff --git a/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java b/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java index 9844917b..7798a263 100644 --- a/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java +++ b/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java @@ -34,18 +34,19 @@ import org.junit.Test; import util.Coordinate; import util.ManhattanDistanceCalculator; +import algorithms.StateUpdates.UpdateStates; import basics.Job; import basics.Service; import basics.costs.VehicleRoutingTransportCosts; import basics.route.Driver; import basics.route.DriverImpl; +import basics.route.DriverImpl.NoDriver; import basics.route.ServiceActivity; import basics.route.TimeWindow; import basics.route.TourActivities; import basics.route.TourActivity; import basics.route.Vehicle; import basics.route.VehicleRoute; -import basics.route.DriverImpl.NoDriver; diff --git a/jsprit-core/src/test/java/algorithms/TestIterateRouteForwardInTime.java b/jsprit-core/src/test/java/algorithms/TestIterateRouteForwardInTime.java index 714aab00..87aab919 100644 --- a/jsprit-core/src/test/java/algorithms/TestIterateRouteForwardInTime.java +++ b/jsprit-core/src/test/java/algorithms/TestIterateRouteForwardInTime.java @@ -10,6 +10,10 @@ import org.junit.Test; import util.Coordinate; import util.ManhattanDistanceCalculator; +import algorithms.StateUpdates.UpdateActivityTimes; +import algorithms.StateUpdates.UpdateCostsAtAllLevels; +import algorithms.StateUpdates.UpdateEarliestStartTimeWindowAtActLocations; +import algorithms.StateUpdates.UpdateLoadAtAllLevels; import basics.Job; import basics.Service; import basics.costs.DefaultVehicleRoutingActivityCosts; diff --git a/jsprit-core/src/test/java/algorithms/TestTourStateUpdaterWithService.java b/jsprit-core/src/test/java/algorithms/TestTourStateUpdaterWithService.java index 6ced378f..1ded2d91 100644 --- a/jsprit-core/src/test/java/algorithms/TestTourStateUpdaterWithService.java +++ b/jsprit-core/src/test/java/algorithms/TestTourStateUpdaterWithService.java @@ -27,6 +27,7 @@ import org.junit.Test; import util.Coordinate; import util.ManhattanDistanceCalculator; +import algorithms.StateUpdates.UpdateStates; import basics.Job; import basics.Service; import basics.costs.VehicleRoutingTransportCosts; @@ -38,7 +39,6 @@ import basics.route.TourActivities; import basics.route.Vehicle; import basics.route.VehicleImpl; import basics.route.VehicleRoute; -import basics.route.VehicleType; import basics.route.VehicleTypeImpl;