diff --git a/jsprit-core/src/main/java/jsprit/core/analysis/SolutionAnalyser.java b/jsprit-core/src/main/java/jsprit/core/analysis/SolutionAnalyser.java index 0964f6f9..539067cd 100644 --- a/jsprit-core/src/main/java/jsprit/core/analysis/SolutionAnalyser.java +++ b/jsprit-core/src/main/java/jsprit/core/analysis/SolutionAnalyser.java @@ -17,25 +17,20 @@ package jsprit.core.analysis; -import jsprit.core.algorithm.state.InternalStates; -import jsprit.core.algorithm.state.StateId; -import jsprit.core.algorithm.state.StateManager; -import jsprit.core.algorithm.state.StateUpdater; +import jsprit.core.algorithm.state.*; import jsprit.core.problem.Capacity; import jsprit.core.problem.VehicleRoutingProblem; -import jsprit.core.problem.constraint.ConstraintManager; -import jsprit.core.problem.constraint.HardActivityConstraint; -import jsprit.core.problem.constraint.HardRouteConstraint; import jsprit.core.problem.solution.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.route.VehicleRoute; -import jsprit.core.problem.solution.route.activity.ActivityVisitor; -import jsprit.core.problem.solution.route.activity.End; -import jsprit.core.problem.solution.route.activity.Start; -import jsprit.core.problem.solution.route.activity.TourActivity; +import jsprit.core.problem.solution.route.activity.*; import jsprit.core.util.ActivityTimeTracker; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; /** * @@ -51,25 +46,87 @@ public class SolutionAnalyser { } -// public static class ViolatedRouteConstraints { -// -// private List hardRouteConstraints = new ArrayList(); -// -// public List getHardRouteConstraints() { -// return hardRouteConstraints; -// } -// -// } -// -// public static class ViolatedActivityConstraints { -// -// private List hardConstraints = new ArrayList(); -// -// public List getHardActivityConstraints() { -// return hardConstraints; -// } -// -// } + private static class BackhaulAndShipmentUpdater implements StateUpdater, ActivityVisitor { + + private final StateId backhaul_id; + + private final StateId shipment_id; + + private final StateManager stateManager; + + private Map openShipments; + + private VehicleRoute route; + + private Boolean shipmentConstraintOnRouteViolated; + + private Boolean backhaulConstraintOnRouteViolated; + + private boolean pickupOccured; + + private BackhaulAndShipmentUpdater(StateId backhaul_id, StateId shipment_id, StateManager stateManager) { + this.stateManager = stateManager; + this.backhaul_id = backhaul_id; + this.shipment_id = shipment_id; + } + + @Override + public void begin(VehicleRoute route) { + this.route = route; + openShipments = new HashMap(); + pickupOccured = false; + shipmentConstraintOnRouteViolated = false; + backhaulConstraintOnRouteViolated = false; + } + + @Override + public void visit(TourActivity activity) { + //shipment + if(activity instanceof PickupShipment){ + openShipments.put(((PickupShipment) activity).getJob().getId(),(PickupShipment)activity); + } + else if(activity instanceof DeliverShipment){ + String jobId = ((DeliverShipment) activity).getJob().getId(); + if(!openShipments.containsKey(jobId)){ + //deliverShipment without pickupShipment + stateManager.putActivityState(activity,shipment_id,true); + shipmentConstraintOnRouteViolated = true; + } + else { + PickupShipment removed = openShipments.remove(jobId); + stateManager.putActivityState(removed,shipment_id,false); + stateManager.putActivityState(activity,shipment_id,false); + } + } + else stateManager.putActivityState(activity,shipment_id,false); + + //backhaul + if(activity instanceof DeliverService && pickupOccured){ + stateManager.putActivityState(activity,backhaul_id,true); + backhaulConstraintOnRouteViolated = true; + } + else{ + if(activity instanceof PickupService || activity instanceof ServiceActivity || activity instanceof PickupShipment){ + pickupOccured = true; + stateManager.putActivityState(activity,backhaul_id,false); + } + else stateManager.putActivityState(activity,backhaul_id,false); + } + } + + @Override + public void finish() { + //shipment + //pickups without deliveries + for(TourActivity act : openShipments.values()){ + stateManager.putActivityState(act,shipment_id,true); + shipmentConstraintOnRouteViolated = true; + } + stateManager.putRouteState(route,shipment_id,shipmentConstraintOnRouteViolated); + //backhaul + stateManager.putRouteState(route,backhaul_id,backhaulConstraintOnRouteViolated); + } + } private static class SumUpActivityTimes implements StateUpdater, ActivityVisitor { @@ -190,68 +247,7 @@ public class SolutionAnalyser { } } -// private static class ConstraintViolationUpdater implements StateUpdater, ActivityVisitor { -// -// private ConstraintManager constraintManager; -// -// private StateManager stateManager; -// -// private StateId violated_route_constraints_id; -// -// private VehicleRoute route; -// -// private List hardRouteConstraints; -// -// private Set examinedJobs = new HashSet(); -// -//// ViolatedRouteConstraints violatedRouteConstraints = new ViolatedRouteConstraints(); -// -// private ConstraintViolationUpdater(ConstraintManager constraintManager, StateManager stateManager, StateId violated_route_constraints_id) { -// this.constraintManager = constraintManager; -// this.stateManager = stateManager; -// this.violated_route_constraints_id = violated_route_constraints_id; -// hardRouteConstraints = getHardRouteConstraints(constraintManager); -// } -// -// private List getHardRouteConstraints(ConstraintManager constraintManager) { -// List constraints = new ArrayList(); -// for(Constraint c : constraintManager.getConstraints()){ -// if(c instanceof HardRouteConstraint){ -// constraints.add((HardRouteConstraint) c); -// } -// } -// return constraints; -// } -// -// @Override -// public void begin(VehicleRoute route) { -// this.route = route; -// examinedJobs.clear(); -//// violatedRouteConstraints.getHardRouteConstraints().clear(); -// } -// -// @Override -// public void visit(TourActivity activity) { -// //hard route constraints -// if(activity instanceof TourActivity.JobActivity){ -// Job job = ((TourActivity.JobActivity) activity).getJob(); -// if(!examinedJobs.contains(job.getId())){ -// examinedJobs.add(job.getId()); -// JobInsertionContext iContext = new JobInsertionContext(route,job,route.getVehicle(),route.getDriver(),route.getDepartureTime()); -// for(HardRouteConstraint hardRouteConstraint : hardRouteConstraints){ -// boolean fulfilled = hardRouteConstraint.fulfilled(iContext); -// if(!fulfilled) violatedRouteConstraints.getHardRouteConstraints().add(hardRouteConstraint); -// } -// } -// } -// -// } -// -// @Override -// public void finish() { -// stateManager.putRouteState(route,violated_route_constraints_id,violatedRouteConstraints); -// } -// } + private static final Logger log = LogManager.getLogger(SolutionAnalyser.class); private VehicleRoutingProblem vrp; @@ -259,8 +255,6 @@ public class SolutionAnalyser { private StateManager stateManager; - private ConstraintManager constraintManager; - private DistanceCalculator distanceCalculator; private final StateId waiting_time_id; @@ -273,18 +267,15 @@ public class SolutionAnalyser { private final StateId too_late_id; -// private final StateId violated_constraint_id; + private final StateId shipment_id; + + private final StateId backhaul_id; private ActivityTimeTracker.ActivityPolicy activityPolicy; - private List hardRouteConstraints; - - private List hardActivityConstraints; private final VehicleRoutingProblemSolution working_solution; -// private final VehicleRoutingProblemSolution original_solution; - public SolutionAnalyser(VehicleRoutingProblem vrp, VehicleRoutingProblemSolution solution, DistanceCalculator distanceCalculator) { this.vrp = vrp; // this.original_solution = VehicleRoutingProblemSolution.copyOf(solution); @@ -294,108 +285,29 @@ public class SolutionAnalyser { this.stateManager.updateTimeWindowStates(); this.stateManager.updateLoadStates(); this.stateManager.updateSkillStates(); - this.constraintManager = new ConstraintManager(vrp,stateManager); + activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS; + this.stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(),activityPolicy)); + this.stateManager.addStateUpdater(new UpdateVariableCosts(vrp.getActivityCosts(),vrp.getTransportCosts(),stateManager)); this.distanceCalculator = distanceCalculator; waiting_time_id = stateManager.createStateId("waiting-time"); transport_time_id = stateManager.createStateId("transport-time"); service_time_id = stateManager.createStateId("service-time"); distance_id = stateManager.createStateId("distance"); too_late_id = stateManager.createStateId("too-late"); -// violated_constraint_id = stateManager.createStateId("violated-constraints"); - activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS; -// if(stateManager.timeWindowUpdateIsActivated()){ -// activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS; -// } + shipment_id = stateManager.createStateId("shipment"); + backhaul_id = stateManager.createStateId("backhaul"); stateManager.addStateUpdater(new SumUpActivityTimes(waiting_time_id, transport_time_id, service_time_id,too_late_id , stateManager, activityPolicy)); stateManager.addStateUpdater(new DistanceUpdater(distance_id,stateManager,distanceCalculator)); -// hardRouteConstraints = getHardRouteConstraints(constraintManager); -// hardActivityConstraints = getHardActivityConstrains(constraintManager); + stateManager.addStateUpdater(new BackhaulAndShipmentUpdater(backhaul_id,shipment_id,stateManager)); refreshStates(); } -// private List getHardActivityConstrains(ConstraintManager constraintManager) { -// List constraints = new ArrayList(); -// for(Constraint c : constraintManager.getConstraints()){ -// if(c instanceof HardActivityConstraint){ -// constraints.add((HardActivityConstraint) c); -// } -// } -// return constraints; -// } private void refreshStates(){ stateManager.clear(); stateManager.informInsertionStarts(routes,null); -// checkConstraintViolation(); } -// private void checkConstraintViolation() { -// for(VehicleRoute route : routes){ -// Set unique = new HashSet(); -// Set examinedJobIds = new HashSet(); -// TourActivity actBeforePrevAct = route.getStart(); -// TourActivity prevAct = null; -// JobInsertionContext prevJobInsertionContext = null; -// for(TourActivity act : route.getActivities()){ -// if(prevAct == null){ -// prevAct = act; -// prevJobInsertionContext = createContext(route,act); -// continue; -// } -// //examine hard route constraints -// if(!examinedJobIds.contains(prevJobInsertionContext.getJob().getId())){ -// examinedJobIds.add(prevJobInsertionContext.getJob().getId()); -// for(HardRouteConstraint hardRouteConstraint : hardRouteConstraints){ -// boolean fulfilled = hardRouteConstraint.fulfilled(prevJobInsertionContext); -// if(!fulfilled) unique.add(hardRouteConstraint); -// } -// } -// -// //exmaine hard activity constraints -// examineActivityConstraints(prevJobInsertionContext, actBeforePrevAct, prevAct, act); -// -// actBeforePrevAct = prevAct; -// prevAct = act; -// prevJobInsertionContext = createContext(route,act); -// } -// examineActivityConstraints(prevJobInsertionContext,actBeforePrevAct,prevAct,route.getEnd()); -// -//// ViolatedRouteConstraints violatedRouteConstraints = new ViolatedRouteConstraints(); -//// violatedRouteConstraints.getHardRouteConstraints().addAll(unique); -//// stateManager.putRouteState(route, violated_constraint_id,violatedRouteConstraints); -// } -// } - -// private void examineActivityConstraints(JobInsertionContext prevJobInsertionContext, TourActivity actBeforePrevAct, TourActivity prevAct, TourActivity act) { -// ViolatedActivityConstraints violatedActivityConstraints = new ViolatedActivityConstraints(); -// for(HardActivityConstraint activityConstraint : hardActivityConstraints){ -// HardActivityConstraint.ConstraintsStatus status = -// activityConstraint.fulfilled(prevJobInsertionContext,actBeforePrevAct,prevAct,act,actBeforePrevAct.getEndTime()); -// if(!status.equals(HardActivityConstraint.ConstraintsStatus.FULFILLED)){ -// violatedActivityConstraints.getHardActivityConstraints().add(activityConstraint); -// } -// } -// stateManager.putActivityState(prevAct, violated_constraint_id,violatedActivityConstraints); -// } - -// private JobInsertionContext createContext(VehicleRoute route, TourActivity act) { -// if(act instanceof TourActivity.JobActivity){ -// return new JobInsertionContext(route,((TourActivity.JobActivity) act).getJob(),route.getVehicle(),route.getDriver(),route.getDepartureTime()); -// } -// throw new IllegalStateException("act not a job activity. this should not be currently"); -// } -// -// private List getHardRouteConstraints(ConstraintManager constraintManager) { -// List constraints = new ArrayList(); -// for(Constraint c : constraintManager.getConstraints()){ -// if(c instanceof HardRouteConstraint){ -// constraints.add((HardRouteConstraint) c); -// } -// } -// return constraints; -// } - -// // // public void informRouteChanged(VehicleRoute route){ // update(route); @@ -408,6 +320,7 @@ public class SolutionAnalyser { * @return load at start location of specified route */ public Capacity getLoadAtBeginning(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return stateManager.getRouteState(route, InternalStates.LOAD_AT_BEGINNING,Capacity.class); } @@ -416,6 +329,7 @@ public class SolutionAnalyser { * @return load at end location of specified route */ public Capacity getLoadAtEnd(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return stateManager.getRouteState(route, InternalStates.LOAD_AT_END,Capacity.class); } @@ -424,6 +338,7 @@ public class SolutionAnalyser { * @return max load of specified route, i.e. for each capacity dimension the max value. */ public Capacity getMaxLoad(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return stateManager.getRouteState(route, InternalStates.MAXLOAD,Capacity.class); } @@ -435,19 +350,31 @@ public class SolutionAnalyser { * Returns null if no load can be found. */ public Capacity getLoadRightAfterActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); if(activity instanceof Start) return getLoadAtBeginning(route); if(activity instanceof End) return getLoadAtEnd(route); + verifyThatRouteContainsAct(activity, route); return stateManager.getActivityState(activity, InternalStates.LOAD, Capacity.class); } + private void verifyThatRouteContainsAct(TourActivity activity, VehicleRoute route) { + if(!route.getTourActivities().hasActivity(activity)){ + throw new IllegalStateException("specified route does not contain specified activity " + activity); + } + } + /** * @param activity to get the load from (before activity) * @return load just before the specified activity. If act is Start, it returns the load atBeginning of the specified * route. If act is End, it returns the load atEnd of specified route. */ public Capacity getLoadJustBeforeActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); if(activity instanceof Start) return getLoadAtBeginning(route); if(activity instanceof End) return getLoadAtEnd(route); + verifyThatRouteContainsAct(activity, route); Capacity afterAct = stateManager.getActivityState(activity, InternalStates.LOAD,Capacity.class); if(afterAct != null && activity.getSize() != null){ return Capacity.subtract(afterAct, activity.getSize()); @@ -461,6 +388,7 @@ public class SolutionAnalyser { * @return the capacity violation on this route, i.e. maxLoad - vehicleCapacity */ public Capacity getCapacityViolation(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); Capacity maxLoad = getMaxLoad(route); return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(maxLoad,route.getVehicle().getType().getCapacityDimensions())); } @@ -472,6 +400,7 @@ public class SolutionAnalyser { * [[dimIndex=0][dimValue=0][dimIndex=1][dimValue=4]] */ public Capacity getCapacityViolationAtBeginning(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); Capacity atBeginning = getLoadAtBeginning(route); return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(atBeginning,route.getVehicle().getType().getCapacityDimensions())); } @@ -483,6 +412,7 @@ public class SolutionAnalyser { * [[dimIndex=0][dimValue=0][dimIndex=1][dimValue=4]] */ public Capacity getCapacityViolationAtEnd(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); Capacity atEnd = getLoadAtEnd(route); return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(atEnd,route.getVehicle().getType().getCapacityDimensions())); } @@ -495,6 +425,8 @@ public class SolutionAnalyser { * [[dimIndex=0][dimValue=0][dimIndex=1][dimValue=4]] */ public Capacity getCapacityViolationAfterActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); Capacity afterAct = getLoadRightAfterActivity(activity,route); return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(afterAct,route.getVehicle().getType().getCapacityDimensions())); } @@ -504,6 +436,7 @@ public class SolutionAnalyser { * @return time violation of route, i.e. sum of individual activity time window violations. */ public Double getTimeWindowViolation(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return stateManager.getRouteState(route,too_late_id,Double.class); } @@ -513,27 +446,48 @@ public class SolutionAnalyser { * @return time violation of activity */ public Double getTimeWindowViolationAtActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); return Math.max(0,activity.getArrTime()-activity.getTheoreticalLatestOperationStartTime()); } public Boolean skillConstraintIsViolated(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return null; } public Boolean skillConstraintIsViolatedAtActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); + verifyThatRouteContainsAct(activity, route); return null; } public Boolean backhaulConstraintIsViolated(VehicleRoute route){ - return null; + return stateManager.getRouteState(route,backhaul_id,Boolean.class); + } + + public Boolean backhaulConstraintIsViolatedAtActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); + if(activity instanceof Start) return false; + if(activity instanceof End) return false; + verifyThatRouteContainsAct(activity, route); + return stateManager.getActivityState(activity,backhaul_id,Boolean.class); } public Boolean shipmentConstraintIsViolated(VehicleRoute route){ - return null; + if(route == null) throw new IllegalStateException("route is missing."); + return stateManager.getRouteState(route,shipment_id,Boolean.class); } public Boolean shipmentConstraintIsViolatedAtActivity(TourActivity activity, VehicleRoute route){ - return null; + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); + if(activity instanceof Start) return false; + if(activity instanceof End) return false; + verifyThatRouteContainsAct(activity, route); + return stateManager.getActivityState(activity,shipment_id,Boolean.class); } @@ -543,6 +497,7 @@ public class SolutionAnalyser { * @return operation time of this route, i.e. endTime - startTime of specified route */ public Double getOperationTime(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return route.getEnd().getArrTime() - route.getStart().getEndTime(); } @@ -552,6 +507,7 @@ public class SolutionAnalyser { * Returns null if no waiting time value exists for the specified route */ public Double getWaitingTime(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return stateManager.getRouteState(route, waiting_time_id, Double.class); } @@ -560,6 +516,7 @@ public class SolutionAnalyser { * @return total transport time of specified route. Returns null if no time value exists for the specified route. */ public Double getTransportTime(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return stateManager.getRouteState(route, transport_time_id, Double.class); } @@ -568,6 +525,7 @@ public class SolutionAnalyser { * @return total service time of specified route. Returns null if no time value exists for specified route. */ public Double getServiceTime(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return stateManager.getRouteState(route, service_time_id, Double.class); } @@ -577,6 +535,8 @@ public class SolutionAnalyser { * vrp.getTransportCosts().getTransportCost(fromId,toId,...) */ public Double getVariableTransportCosts(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + return stateManager.getRouteState(route,InternalStates.COSTS,Double.class); } @@ -585,26 +545,10 @@ public class SolutionAnalyser { * @return fixed costs of route, i.e. fixed costs of employed vehicle on this route. */ public Double getFixedCosts(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return route.getVehicle().getType().getVehicleCostParams().fix; } -// public ViolatedRouteConstraints getViolatedHardConstraints(VehicleRoute route){ -// return stateManager.getRouteState(route, violated_constraint_id,ViolatedRouteConstraints.class); -// } - -// public Map getViolatedSoftConstraints(VehicleRoute route){ -// return null; -// } - -// public ViolatedActivityConstraints getViolatedHardConstraintsAtActivity(TourActivity activity, VehicleRoute route){ -// if(activity instanceof Start) return new ViolatedActivityConstraints(); -// if(activity instanceof End) return new ViolatedActivityConstraints(); -// return stateManager.getActivityState(activity,violated_constraint_id,ViolatedActivityConstraints.class); -// } - -// public Map getViolatedSoftConstraint(VehicleRoute route){ -// return null; -// } /** * @param activity to get the variable transport costs from @@ -613,8 +557,11 @@ public class SolutionAnalyser { * If activity is start, it returns 0.. If it is end, it returns .getVariableTransportCosts(route). */ public Double getVariableTransportCostsAtActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); if(activity instanceof Start) return 0.; if(activity instanceof End) return getVariableTransportCosts(route); + verifyThatRouteContainsAct(activity, route); return stateManager.getActivityState(activity,InternalStates.COSTS,Double.class); } @@ -624,6 +571,8 @@ public class SolutionAnalyser { * @return waiting time at activity */ public Double getWaitingTimeAtActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); double waitingTime = 0.; if(activityPolicy.equals(ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS)){ waitingTime = Math.max(0,activity.getTheoreticalEarliestOperationStartTime()-activity.getArrTime()); @@ -636,6 +585,8 @@ public class SolutionAnalyser { * @return time too late */ public Double getLateArrivalTimesAtActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); double tooLate = 0.; if(activityPolicy.equals(ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS)){ tooLate = Math.max(0,activity.getArrTime()-activity.getTheoreticalLatestOperationStartTime()); @@ -648,6 +599,7 @@ public class SolutionAnalyser { * @return time too late, i.e. sum of late time of activities */ public Double getLateArrivalTimes(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return stateManager.getRouteState(route,too_late_id,Double.class); } @@ -656,6 +608,7 @@ public class SolutionAnalyser { * @return total distance of route */ public Double getDistance(VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); return stateManager.getRouteState(route, distance_id, Double.class); } @@ -664,8 +617,11 @@ public class SolutionAnalyser { * @return distance at activity */ public Double getDistanceAtActivity(TourActivity activity, VehicleRoute route){ + if(route == null) throw new IllegalStateException("route is missing."); + if(activity == null) throw new IllegalStateException("activity is missing."); if(activity instanceof Start) return 0.; if(activity instanceof End) return getDistance(route); + verifyThatRouteContainsAct(activity, route); return stateManager.getActivityState(activity, distance_id, Double.class); } diff --git a/jsprit-core/src/test/java/jsprit/core/analysis/SolutionAnalyserTest.java b/jsprit-core/src/test/java/jsprit/core/analysis/SolutionAnalyserTest.java index e719d1f3..3bac4cca 100644 --- a/jsprit-core/src/test/java/jsprit/core/analysis/SolutionAnalyserTest.java +++ b/jsprit-core/src/test/java/jsprit/core/analysis/SolutionAnalyserTest.java @@ -18,12 +18,8 @@ package jsprit.core.analysis; -import jsprit.core.algorithm.VehicleRoutingAlgorithm; -import jsprit.core.algorithm.VehicleRoutingAlgorithmBuilder; -import jsprit.core.algorithm.state.StateManager; import jsprit.core.problem.Capacity; import jsprit.core.problem.VehicleRoutingProblem; -import jsprit.core.problem.constraint.ConstraintManager; import jsprit.core.problem.job.Delivery; import jsprit.core.problem.job.Pickup; import jsprit.core.problem.job.Service; @@ -38,11 +34,11 @@ import jsprit.core.problem.vehicle.VehicleTypeImpl; import jsprit.core.reporting.SolutionPrinter; import jsprit.core.util.Coordinate; import jsprit.core.util.ManhattanCosts; -import jsprit.core.util.Solutions; import junit.framework.Assert; import org.junit.Before; import org.junit.Test; +import java.util.Arrays; import java.util.Iterator; import static org.junit.Assert.*; @@ -53,9 +49,6 @@ public class SolutionAnalyserTest { private VehicleRoutingProblemSolution solution; - private StateManager stateManager; - - private ConstraintManager constraintManager; private SolutionAnalyser.DistanceCalculator distanceCalculator; @@ -93,18 +86,13 @@ public class SolutionAnalyserTest { vrpBuilder.setRoutingCost(new ManhattanCosts(vrpBuilder.getLocations())); vrp = vrpBuilder.build(); - VehicleRoutingAlgorithmBuilder vraBuilder = new VehicleRoutingAlgorithmBuilder(vrp,"src/test/resources/algorithmConfig.xml"); - vraBuilder.addDefaultCostCalculators(); - vraBuilder.addCoreConstraints(); - stateManager = new StateManager(vrp); - stateManager.updateLoadStates(); - constraintManager = new ConstraintManager(vrp,stateManager); - vraBuilder.setStateAndConstraintManager(stateManager,constraintManager); + VehicleRoute route1 = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()) + .addService(s1).addPickup(shipment1).addDelivery(shipment1).addService(s2).build(); - VehicleRoutingAlgorithm vra = vraBuilder.build(); - vra.setMaxIterations(100); - solution = Solutions.bestOf(vra.searchSolutions()); + VehicleRoute route2 = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()) + .addService(s3).addPickup(shipment2).addDelivery(shipment2).addService(s4).build(); + solution = new VehicleRoutingProblemSolution(Arrays.asList(route1,route2),42); } @Test @@ -244,21 +232,6 @@ public class SolutionAnalyserTest { Assert.assertEquals(5, analyser.getLoadRightAfterActivity(route.getEnd(), route).get(0)); } - @Test - public void whatShouldHappenWithAllActStatistics_IfSpecifiedActIsNotInVehicleRoute(){ - /* - there might be the need to add .containsActivity(act) to VehicleRoute - */ - Assert.assertTrue(false); - } - - @Test - public void whatShouldHappenWithAllActStatistics_IfSpecifiedActIsNull(){ - Assert.assertTrue(false); - } - - - @Test public void loadBeforeActivity_ofStartActOfRoute1ShouldWork(){ SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { @@ -734,11 +707,6 @@ public class SolutionAnalyserTest { Assert.assertEquals(42.*2., analyser.getVariableTransportCostsAtActivity(route.getEnd(), route), 0.01); } - @Test - public void whatShouldHappenIf_Route_or_Activity_isEmpty_or_notPartOfRoute(){ - assertFalse(true); - } - @Test public void capacityViolationAtBeginning_shouldWork(){ SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { @@ -1265,8 +1233,460 @@ public class SolutionAnalyserTest { } @Test - public void testRealViolation(){ - assertFalse(true); + public void backhaulViolation_shouldWorkWhenViolated(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolated(route); + assertTrue(violation); + } + + @Test + public void backhaulViolationAtStart_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getStart(), route); + assertFalse(violation); + } + + @Test + public void backhaulViolationAtAct1_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(0),route); + assertFalse(violation); + } + + @Test + public void backhaulViolationAtAct2_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(1),route); + assertFalse(violation); + } + + @Test + public void backhaulViolationAtAct3_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(2),route); + assertFalse(violation); + } + + @Test + public void backhaulViolationAtAct4_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(3),route); + assertTrue(violation); + } + + @Test + public void backhaulViolationAtAct5_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(4),route); + assertTrue(violation); + } + + @Test + public void backhaulViolationAtAct6_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(5),route); + assertFalse(violation); + } + + @Test + public void backhaulViolationAtAct7_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(6),route); + assertFalse(violation); + } + + @Test + public void backhaulViolationAtAct8_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(7),route); + assertFalse(violation); + } + + @Test + public void backhaulViolationAtEnd_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getEnd(),route); + assertFalse(violation); + } + + @Test + public void shipmentViolationAtStart_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.shipmentConstraintIsViolatedAtActivity(route.getStart(), route); + assertFalse(violation); + } + + @Test + public void shipmentViolationAtAct1_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(0),route); + assertFalse(violation); + } + + @Test + public void shipmentViolationAtAct2_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(1),route); + assertFalse(violation); + } + + @Test + public void shipmentViolationAtAct3_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(2),route); + assertFalse(violation); + } + + @Test + public void shipmentViolationAtAct4_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(3),route); + assertTrue(violation); + } + + @Test + public void shipmentViolationAtAct5_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(4),route); + assertTrue(violation); + } + + @Test + public void shipmentViolationAtAct6_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(5),route); + assertFalse(violation); + } + + @Test + public void shipmentViolationAtAct7_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(6),route); + assertFalse(violation); + } + + @Test + public void shipmentViolationAtAct8_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(7),route); + assertFalse(violation); + } + + @Test + public void shipmentViolationAtEnd_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getEnd(),route); + assertFalse(violation); + } + + @Test + public void shipmentViolation_shouldWork(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + VehicleRoute route = solution.getRoutes().iterator().next(); + Boolean violation = analyser.shipmentConstraintIsViolated(route); + assertFalse(violation); + } + + @Test + public void shipmentViolation_shouldWorkWhenViolated(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + VehicleRoute route = solution.getRoutes().iterator().next(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + TourActivity deliverShipment = route.getActivities().get(2); + route.getTourActivities().removeActivity(deliverShipment); +// SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + + Boolean violation = analyser.shipmentConstraintIsViolated(route); + assertTrue(violation); + } + + @Test + public void shipmentViolationAtActivity_shouldWorkWhenRemovingDelivery(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + VehicleRoute route = solution.getRoutes().iterator().next(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + TourActivity deliverShipment = route.getActivities().get(2); + route.getTourActivities().removeActivity(deliverShipment); +// assertFalse(route.getTourActivities().hasActivity(pickupShipment)); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + + Boolean violation = analyser.shipmentConstraintIsViolatedAtActivity(route.getActivities().get(1), route); + assertTrue(violation); + } + + @Test + public void shipmentViolation_shouldWorkWhenRemovingDelivery(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + VehicleRoute route = solution.getRoutes().iterator().next(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + TourActivity deliverShipment = route.getActivities().get(2); + route.getTourActivities().removeActivity(deliverShipment); + assertFalse(route.getTourActivities().hasActivity(deliverShipment)); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + + Boolean violation = analyser.shipmentConstraintIsViolated(route); + assertTrue(violation); + } + + @Test + public void shipmentViolationAtActivity_shouldWorkWhenRemovingPickup(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + VehicleRoute route = solution.getRoutes().iterator().next(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + TourActivity pickupShipment = route.getActivities().get(1); + route.getTourActivities().removeActivity(pickupShipment); + assertFalse(route.getTourActivities().hasActivity(pickupShipment)); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + + Boolean violation = analyser.shipmentConstraintIsViolatedAtActivity(route.getActivities().get(1),route); + assertTrue(violation); + } + + @Test + public void shipmentViolationOnRoute_shouldWorkWhenRemovingPickup(){ + buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); + VehicleRoute route = solution.getRoutes().iterator().next(); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + TourActivity pickupShipment = route.getActivities().get(1); + route.getTourActivities().removeActivity(pickupShipment); + assertFalse(route.getTourActivities().hasActivity(pickupShipment)); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + + SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { + @Override + public double getDistance(String fromLocationId, String toLocationId) { + return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); + } + }); + + Boolean violation = analyser.shipmentConstraintIsViolated(route); + assertTrue(violation); } @@ -1316,68 +1736,32 @@ public class SolutionAnalyserTest { vrpBuilder.setRoutingCost(new ManhattanCosts(vrpBuilder.getLocations())); vrp = vrpBuilder.build(); - VehicleRoutingAlgorithmBuilder vraBuilder = new VehicleRoutingAlgorithmBuilder(vrp,"src/test/resources/algorithmConfig.xml"); - vraBuilder.addDefaultCostCalculators(); + VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()) + .addPickup(s3) + .addPickup(shipment2).addDelivery(shipment2) + .addDelivery(s4) + .addDelivery(s2) + .addPickup(shipment1).addDelivery(shipment1) + .addPickup(s1) + .build(); - //adds updater - stateManager = new StateManager(vrp); - stateManager.updateLoadStates(); - stateManager.updateTimeWindowStates(); - - //but no constraints to simulate violation - ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); - vraBuilder.setStateAndConstraintManager(stateManager,constraintManager); - - VehicleRoutingAlgorithm vra = vraBuilder.build(); - vra.setMaxIterations(100); - solution = Solutions.bestOf(vra.searchSolutions()); + solution = new VehicleRoutingProblemSolution(Arrays.asList(route),300); +// VehicleRoutingAlgorithmBuilder vraBuilder = new VehicleRoutingAlgorithmBuilder(vrp,"src/test/resources/algorithmConfig.xml"); +// vraBuilder.addDefaultCostCalculators(); +// +// //adds updater +// StateManager stateManager = new StateManager(vrp); +// stateManager.updateLoadStates(); +// stateManager.updateTimeWindowStates(); +// +// //but no constraints to simulate violation +// ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); +// vraBuilder.setStateAndConstraintManager(stateManager,constraintManager); +// +// VehicleRoutingAlgorithm vra = vraBuilder.build(); +// vra.setMaxIterations(100); +// solution = Solutions.bestOf(vra.searchSolutions()); } -// -// public void simulateTW_and_LoadConstraint(){ -// constraintManager.addLoadConstraint(); -// constraintManager.addTimeWindowConstraint(); -// } - -// @Test -// public void violatedConstraint_shouldReturnTWandCapConstraints(){ -// buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); -// -// SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); -// -// simulateTW_and_LoadConstraint(); -// -// SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { -// @Override -// public double getDistance(String fromLocationId, String toLocationId) { -// return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); -// } -// }); -// VehicleRoute route = solution.getRoutes().iterator().next(); -// List violatedConstraints = analyser.getViolatedHardConstraints(route).getHardRouteConstraints(); -//// Assert.assertEquals(2,violatedConstraints.size()); -// for(HardRouteConstraint c : violatedConstraints) System.out.println("violated: " + c.getClass().toString()); -// } -// -// @Test -// public void violatedActivityConstraint_shouldWorkForAct1(){ -// buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore(); -// -// SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); -// -// simulateTW_and_LoadConstraint(); -// -// SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() { -// @Override -// public double getDistance(String fromLocationId, String toLocationId) { -// return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null); -// } -// }); -// -// VehicleRoute route = solution.getRoutes().iterator().next(); -// List violatedConstraints = analyser.getViolatedHardConstraintsAtActivity(route.getActivities().get(0),route).getHardActivityConstraints(); -//// Assert.assertEquals(2,violatedConstraints.size()); -// for(HardActivityConstraint c : violatedConstraints) System.out.println("violated: " + c.getClass().toString()); -// } }