mirror of
https://github.com/graphhopper/jsprit.git
synced 2020-01-24 07:45:05 +01:00
add and test constraint violation checks
This commit is contained in:
oblonski
parent
f733587b2b
commit
47d859652a
2 changed files with 645 additions and 305 deletions
|
|
@ -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<HardRouteConstraint> hardRouteConstraints = new ArrayList<HardRouteConstraint>();
|
||||
//
|
||||
// public List<HardRouteConstraint> getHardRouteConstraints() {
|
||||
// return hardRouteConstraints;
|
||||
// }
|
||||
//
|
||||
// }
|
||||
//
|
||||
// public static class ViolatedActivityConstraints {
|
||||
//
|
||||
// private List<HardActivityConstraint> hardConstraints = new ArrayList<HardActivityConstraint>();
|
||||
//
|
||||
// public List<HardActivityConstraint> 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<String,PickupShipment> 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<String, PickupShipment>();
|
||||
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<HardRouteConstraint> hardRouteConstraints;
|
||||
//
|
||||
// private Set<String> examinedJobs = new HashSet<String>();
|
||||
//
|
||||
//// 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<HardRouteConstraint> getHardRouteConstraints(ConstraintManager constraintManager) {
|
||||
// List<HardRouteConstraint> constraints = new ArrayList<HardRouteConstraint>();
|
||||
// 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<HardRouteConstraint> hardRouteConstraints;
|
||||
|
||||
private List<HardActivityConstraint> 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<HardActivityConstraint> getHardActivityConstrains(ConstraintManager constraintManager) {
|
||||
// List<HardActivityConstraint> constraints = new ArrayList<HardActivityConstraint>();
|
||||
// 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<HardRouteConstraint> unique = new HashSet<HardRouteConstraint>();
|
||||
// Set<String> examinedJobIds = new HashSet<String>();
|
||||
// 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<HardRouteConstraint> getHardRouteConstraints(ConstraintManager constraintManager) {
|
||||
// List<HardRouteConstraint> constraints = new ArrayList<HardRouteConstraint>();
|
||||
// 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<SoftRouteConstraint,Double> 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<SoftRouteConstraint,Double> 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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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<HardRouteConstraint> 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<HardActivityConstraint> 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());
|
||||
// }
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue