trans/graphhopper-jsprit
1
0
Fork 0
mirror of https://github.com/graphhopper/jsprit.git synced 2020-01-24 07:45:05 +01:00
Code Issues Releases Wiki Activity

Merge branch 'pickupAndDelivery' into PickupMergeRelaxAPI

Browse source 
Conflicts:
	jsprit-core/src/main/java/algorithms/BestInsertionBuilder.java
	jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithmFactoryImpl.java
	jsprit-core/src/test/java/algorithms/BuildPDVRPWithShipmentsAlgoFromScratchTest.java
	jsprit-core/src/test/resources/pdp_sol.xml
This commit is contained in:
Stefan Schroeder 2013-11-21 12:20:59 +01:00
commit a9da587f6a
35 changed files with 609 additions and 36828 deletions
Download patch file Download diff file Expand all files Collapse all files

21
jsprit-analysis/src/main/java/analysis/Plotter.java
View file

@ -85,6 +85,8 @@ public class Plotter {
private boolean plotSolutionAsWell = false; private boolean plotSolutionAsWell = false;
private boolean plotShipments = true; private boolean plotShipments = true;
private Collection<VehicleRoute> routes;
public void setShowFirstActivity(boolean show){ public void setShowFirstActivity(boolean show){
showFirstActivity = show; showFirstActivity = show;
@ -102,13 +104,20 @@ public class Plotter {
public Plotter(VehicleRoutingProblem vrp, VehicleRoutingProblemSolution solution) { public Plotter(VehicleRoutingProblem vrp, VehicleRoutingProblemSolution solution) {
super(); super();
this.vrp = vrp; this.vrp = vrp;
this.solution = solution; this.routes = solution.getRoutes();
plotSolutionAsWell = true; plotSolutionAsWell = true;
} }
public Plotter(VehicleRoutingProblem vrp, Collection<VehicleRoute> routes) {
super();
this.vrp = vrp;
this.routes = routes;
plotSolutionAsWell = true;
}
public void plot(String pngFileName, String plotTitle){ public void plot(String pngFileName, String plotTitle){
if(plotSolutionAsWell){ if(plotSolutionAsWell){
plotSolutionAsPNG(vrp, solution, pngFileName, plotTitle); plotSolutionAsPNG(vrp, routes, pngFileName, plotTitle);
} }
else{ else{
plotVrpAsPNG(vrp, pngFileName, plotTitle); plotVrpAsPNG(vrp, pngFileName, plotTitle);
@ -149,7 +158,7 @@ public class Plotter {
save(chart,pngFile); save(chart,pngFile);
} }
private void plotSolutionAsPNG(VehicleRoutingProblem vrp, VehicleRoutingProblemSolution solution, String pngFile, String title){ private void plotSolutionAsPNG(VehicleRoutingProblem vrp, Collection<VehicleRoute> routes, String pngFile, String title){
log.info("plot solution to " + pngFile); log.info("plot solution to " + pngFile);
XYSeriesCollection problem; XYSeriesCollection problem;
XYSeriesCollection solutionColl; XYSeriesCollection solutionColl;
@ -158,7 +167,7 @@ public class Plotter {
try { try {
problem = makeVrpSeries(vrp, labels); problem = makeVrpSeries(vrp, labels);
shipments = makeShipmentSeries(vrp.getJobs().values(), null); shipments = makeShipmentSeries(vrp.getJobs().values(), null);
solutionColl = makeSolutionSeries(vrp, solution); solutionColl = makeSolutionSeries(vrp, routes);
} catch (NoLocationFoundException e) { } catch (NoLocationFoundException e) {
log.warn("cannot plot vrp, since coord is missing"); log.warn("cannot plot vrp, since coord is missing");
return; return;
@ -305,11 +314,11 @@ public class Plotter {
} }
} }
private XYSeriesCollection makeSolutionSeries(VehicleRoutingProblem vrp, VehicleRoutingProblemSolution solution) throws NoLocationFoundException{ private XYSeriesCollection makeSolutionSeries(VehicleRoutingProblem vrp, Collection<VehicleRoute> routes) throws NoLocationFoundException{
Locations locations = retrieveLocations(vrp); Locations locations = retrieveLocations(vrp);
XYSeriesCollection coll = new XYSeriesCollection(); XYSeriesCollection coll = new XYSeriesCollection();
int counter = 1; int counter = 1;
for(VehicleRoute route : solution.getRoutes()){ for(VehicleRoute route : routes){
if(route.isEmpty()) continue; if(route.isEmpty()) continue;
XYSeries series = new XYSeries(counter, false, true); XYSeries series = new XYSeries(counter, false, true);

1
jsprit-core/src/main/java/algorithms/BestInsertionBuilder.java
View file

@ -107,4 +107,5 @@ public class BestInsertionBuilder {
return bestInsertion; return bestInsertion;
} }
} }

4
jsprit-core/src/main/java/algorithms/CalculatorBuilder.java
View file

@ -19,6 +19,8 @@ package algorithms;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import basics.Delivery;
import basics.Pickup;
import basics.Service; import basics.Service;
import basics.Shipment; import basics.Shipment;
import basics.VehicleRoutingProblem; import basics.VehicleRoutingProblem;
@ -238,6 +240,8 @@ class CalculatorBuilder {
JobCalculatorSwitcher switcher = new JobCalculatorSwitcher(); JobCalculatorSwitcher switcher = new JobCalculatorSwitcher();
switcher.put(Shipment.class, shipmentInsertion); switcher.put(Shipment.class, shipmentInsertion);
switcher.put(Service.class, serviceInsertion); switcher.put(Service.class, serviceInsertion);
switcher.put(Pickup.class, serviceInsertion);
switcher.put(Delivery.class, serviceInsertion);
// JobInsertionCostsCalculator standardServiceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), actInsertionCalc, constraintManager, constraintManager); // JobInsertionCostsCalculator standardServiceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), actInsertionCalc, constraintManager, constraintManager);
// ((ServiceInsertionCalculator) standardServiceInsertion).setNeighborhood(vrp.getNeighborhood()); // ((ServiceInsertionCalculator) standardServiceInsertion).setNeighborhood(vrp.getNeighborhood());

22
jsprit-core/src/main/java/algorithms/ConstraintManager.java
View file

@ -1,10 +1,15 @@
package algorithms; package algorithms;
import basics.VehicleRoutingProblem; import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblem.Constraint;
import basics.route.TourActivity; import basics.route.TourActivity;
public class ConstraintManager implements HardActivityStateLevelConstraint, HardRouteStateLevelConstraint{ public class ConstraintManager implements HardActivityStateLevelConstraint, HardRouteStateLevelConstraint{
public static enum Priority {
CRITICAL, HIGH, LOW
}
private HardActivityLevelConstraintManager actLevelConstraintManager = new HardActivityLevelConstraintManager(); private HardActivityLevelConstraintManager actLevelConstraintManager = new HardActivityLevelConstraintManager();
private HardRouteLevelConstraintManager routeLevelConstraintManager = new HardRouteLevelConstraintManager(); private HardRouteLevelConstraintManager routeLevelConstraintManager = new HardRouteLevelConstraintManager();
@ -24,7 +29,7 @@ public class ConstraintManager implements HardActivityStateLevelConstraint, Hard
public void addTimeWindowConstraint(){ public void addTimeWindowConstraint(){
if(!timeWindowConstraintsSet){ if(!timeWindowConstraintsSet){
addConstraint(new TimeWindowConstraint(stateManager, vrp.getTransportCosts())); addConstraint(new TimeWindowConstraint(stateManager, vrp.getTransportCosts()),Priority.HIGH);
stateManager.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts())); stateManager.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts()));
timeWindowConstraintsSet = true; timeWindowConstraintsSet = true;
} }
@ -32,19 +37,24 @@ public class ConstraintManager implements HardActivityStateLevelConstraint, Hard
public void addLoadConstraint(){ public void addLoadConstraint(){
if(!loadConstraintsSet){ if(!loadConstraintsSet){
if(vrp.getProblemConstraints().contains(Constraint.DELIVERIES_FIRST)){
addConstraint(new ServiceBackhaulConstraint(),Priority.HIGH);
}
addConstraint(new PickupAndDeliverShipmentLoadActivityLevelConstraint(stateManager),Priority.CRITICAL);
addConstraint(new ServiceLoadRouteLevelConstraint(stateManager)); addConstraint(new ServiceLoadRouteLevelConstraint(stateManager));
addConstraint(new ServiceLoadActivityLevelConstraint(stateManager)); addConstraint(new ServiceLoadActivityLevelConstraint(stateManager),Priority.LOW);
UpdateLoads updateLoads = new UpdateLoads(stateManager); UpdateLoads updateLoads = new UpdateLoads(stateManager);
stateManager.addActivityVisitor(updateLoads); stateManager.addActivityVisitor(updateLoads);
stateManager.addListener(updateLoads); stateManager.addListener(updateLoads);
stateManager.addActivityVisitor(new UpdateFuturePickups(stateManager)); stateManager.addActivityVisitor(new UpdateMaxLoad(stateManager));
stateManager.addActivityVisitor(new UpdateOccuredDeliveries(stateManager)); stateManager.addActivityVisitor(new UpdateMaxLoad_(stateManager));
stateManager.addActivityVisitor(new UpdatePrevMaxLoad(stateManager));
loadConstraintsSet=true; loadConstraintsSet=true;
} }
} }
public void addConstraint(HardActivityStateLevelConstraint actLevelConstraint){ public void addConstraint(HardActivityStateLevelConstraint actLevelConstraint, Priority priority){
actLevelConstraintManager.addConstraint(actLevelConstraint); actLevelConstraintManager.addConstraint(actLevelConstraint,priority);
} }
public void addConstraint(HardRouteStateLevelConstraint routeLevelConstraint){ public void addConstraint(HardRouteStateLevelConstraint routeLevelConstraint){

2
jsprit-core/src/main/java/algorithms/Gendreau.java
View file

@ -36,8 +36,8 @@ import basics.algo.RuinListener;
import basics.algo.SearchStrategyModule; import basics.algo.SearchStrategyModule;
import basics.algo.SearchStrategyModuleListener; import basics.algo.SearchStrategyModuleListener;
import basics.route.TourActivity; import basics.route.TourActivity;
import basics.route.VehicleFleetManager;
import basics.route.TourActivity.JobActivity; import basics.route.TourActivity.JobActivity;
import basics.route.VehicleFleetManager;
import basics.route.VehicleRoute; import basics.route.VehicleRoute;
public final class Gendreau implements SearchStrategyModule{ public final class Gendreau implements SearchStrategyModule{

49
jsprit-core/src/main/java/algorithms/HardActivityLevelConstraintManager.java
View file

@ -3,24 +3,65 @@ package algorithms;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import algorithms.ConstraintManager.Priority;
import basics.route.TourActivity; import basics.route.TourActivity;
class HardActivityLevelConstraintManager implements HardActivityStateLevelConstraint { class HardActivityLevelConstraintManager implements HardActivityStateLevelConstraint {
private Collection<HardActivityStateLevelConstraint> hardConstraints = new ArrayList<HardActivityStateLevelConstraint>(); private Collection<HardActivityStateLevelConstraint> criticalConstraints = new ArrayList<HardActivityStateLevelConstraint>();
public void addConstraint(HardActivityStateLevelConstraint constraint){ private Collection<HardActivityStateLevelConstraint> highPrioConstraints = new ArrayList<HardActivityStateLevelConstraint>();
hardConstraints.add(constraint);
private Collection<HardActivityStateLevelConstraint> lowPrioConstraints = new ArrayList<HardActivityStateLevelConstraint>();
public void addConstraint(HardActivityStateLevelConstraint constraint, Priority priority){
if(priority.equals(Priority.CRITICAL)){
criticalConstraints.add(constraint);
}
else if(priority.equals(Priority.HIGH)){
highPrioConstraints.add(constraint);
}
else{
lowPrioConstraints.add(constraint);
}
} }
@Override @Override
public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) { public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
for(HardActivityStateLevelConstraint constraint : hardConstraints){ ConstraintsStatus notFulfilled = null;
for(HardActivityStateLevelConstraint c : criticalConstraints){
ConstraintsStatus status = c.fulfilled(iFacts, prevAct, newAct, nextAct, prevActDepTime);
if(status.equals(ConstraintsStatus.NOT_FULFILLED_BREAK)){
return status;
}
else{
if(status.equals(ConstraintsStatus.NOT_FULFILLED)){
notFulfilled = status;
}
}
}
if(notFulfilled != null) return notFulfilled;
for(HardActivityStateLevelConstraint c : highPrioConstraints){
ConstraintsStatus status = c.fulfilled(iFacts, prevAct, newAct, nextAct, prevActDepTime);
if(status.equals(ConstraintsStatus.NOT_FULFILLED_BREAK)){
return status;
}
else{
if(status.equals(ConstraintsStatus.NOT_FULFILLED)){
notFulfilled = status;
}
}
}
if(notFulfilled != null) return notFulfilled;
for(HardActivityStateLevelConstraint constraint : lowPrioConstraints){
ConstraintsStatus status = constraint.fulfilled(iFacts, prevAct, newAct, nextAct, prevActDepTime); ConstraintsStatus status = constraint.fulfilled(iFacts, prevAct, newAct, nextAct, prevActDepTime);
if(status.equals(ConstraintsStatus.NOT_FULFILLED_BREAK) || status.equals(ConstraintsStatus.NOT_FULFILLED)){ if(status.equals(ConstraintsStatus.NOT_FULFILLED_BREAK) || status.equals(ConstraintsStatus.NOT_FULFILLED)){
return status; return status;
} }
} }
return ConstraintsStatus.FULFILLED; return ConstraintsStatus.FULFILLED;
} }

76
jsprit-core/src/main/java/algorithms/HardPickupAndDeliveryShipmentActivityLevelConstraint.java
View file

@ -1,76 +0,0 @@
package algorithms;
import org.apache.log4j.Logger;
import algorithms.HardActivityStateLevelConstraint.ConstraintsStatus;
import basics.route.DeliverShipment;
import basics.route.PickupShipment;
import basics.route.Start;
import basics.route.TourActivity;
public class HardPickupAndDeliveryShipmentActivityLevelConstraint implements HardActivityStateLevelConstraint {
private static Logger logger = Logger.getLogger(HardPickupAndDeliveryShipmentActivityLevelConstraint.class);
private StateManager stateManager;
private boolean backhaul = false;
public HardPickupAndDeliveryShipmentActivityLevelConstraint(StateManager stateManager) {
super();
this.stateManager = stateManager;
}
public HardPickupAndDeliveryShipmentActivityLevelConstraint(StateManager stateManager, boolean backhaul) {
super();
this.stateManager = stateManager;
this.backhaul = backhaul;
}
@Override
public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
// logger.info(prevAct + " - " + newAct + " - " + nextAct);
if(!(newAct instanceof PickupShipment) && !(newAct instanceof DeliverShipment)){
return ConstraintsStatus.FULFILLED;
}
if(backhaul){
if(newAct instanceof PickupShipment && prevAct instanceof DeliverShipment){
// logger.info("NOT_FULFILLED_BREAK");
return ConstraintsStatus.NOT_FULFILLED_BREAK; }
if(newAct instanceof DeliverShipment && nextAct instanceof PickupShipment){
// logger.info("NOT_FULFILLED");
return ConstraintsStatus.NOT_FULFILLED; }
}
int loadAtPrevAct;
// int futurePicks;
// int pastDeliveries;
if(prevAct instanceof Start){
loadAtPrevAct = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.LOAD_AT_BEGINNING).toDouble();
// futurePicks = (int)stateManager.getRouteState(iFacts.getRoute(), StateTypes.LOAD).toDouble();
// pastDeliveries = 0;
}
else{
loadAtPrevAct = (int) stateManager.getActivityState(prevAct, StateFactory.LOAD).toDouble();
// futurePicks = (int) stateManager.getActivityState(prevAct, StateTypes.FUTURE_PICKS).toDouble();
// pastDeliveries = (int) stateManager.getActivityState(prevAct, StateTypes.PAST_DELIVERIES).toDouble();
}
if(newAct instanceof PickupShipment){
if(loadAtPrevAct + newAct.getCapacityDemand() > iFacts.getNewVehicle().getCapacity()){
// logger.info("NOT_FULFILLED");
return ConstraintsStatus.NOT_FULFILLED;
}
}
if(newAct instanceof DeliverShipment){
if(loadAtPrevAct + Math.abs(newAct.getCapacityDemand()) > iFacts.getNewVehicle().getCapacity()){
// logger.info("NOT_FULFILLED_BREAK");
return ConstraintsStatus.NOT_FULFILLED_BREAK;
}
}
// logger.info("FULFILLED");
return ConstraintsStatus.FULFILLED;
}
}

2
jsprit-core/src/main/java/algorithms/Inserter.java
View file

@ -16,8 +16,6 @@
******************************************************************************/ ******************************************************************************/
package algorithms; package algorithms;
import org.apache.log4j.Logger;
import algorithms.InsertionData.NoInsertionFound; import algorithms.InsertionData.NoInsertionFound;
import basics.Job; import basics.Job;
import basics.Service; import basics.Service;

65
jsprit-core/src/main/java/algorithms/PickupAndDeliverShipmentLoadActivityLevelConstraint.java Normal file
View file

@ -0,0 +1,65 @@
package algorithms;
import org.apache.log4j.Logger;
import basics.route.DeliverShipment;
import basics.route.PickupShipment;
import basics.route.Start;
import basics.route.TourActivity;
/**
* Constraint that ensures capacity constraint at each activity.
*
* <p>This is critical to consistently calculate pd-problems with capacity constraints. Critical means
* that is MUST be visited. It also assumes that pd-activities are visited in the order they occur in a tour.
*
* @author schroeder
*
*/
public class PickupAndDeliverShipmentLoadActivityLevelConstraint implements HardActivityStateLevelConstraint {
private static Logger logger = Logger.getLogger(PickupAndDeliverShipmentLoadActivityLevelConstraint.class);
private StateManager stateManager;
/**
* Constructs the constraint ensuring capacity constraint at each activity.
*
* <p>This is critical to consistently calculate pd-problems with capacity constraints. Critical means
* that is MUST be visited. It also assumes that pd-activities are visited in the order they occur in a tour.
*
*
* @param stateManager
*/
public PickupAndDeliverShipmentLoadActivityLevelConstraint(StateManager stateManager) {
super();
this.stateManager = stateManager;
}
@Override
public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
if(!(newAct instanceof PickupShipment) && !(newAct instanceof DeliverShipment)){
return ConstraintsStatus.FULFILLED;
}
int loadAtPrevAct;
if(prevAct instanceof Start){
loadAtPrevAct = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.LOAD_AT_BEGINNING).toDouble();
}
else{
loadAtPrevAct = (int) stateManager.getActivityState(prevAct, StateFactory.LOAD).toDouble();
}
if(newAct instanceof PickupShipment){
if(loadAtPrevAct + newAct.getCapacityDemand() > iFacts.getNewVehicle().getCapacity()){
return ConstraintsStatus.NOT_FULFILLED;
}
}
if(newAct instanceof DeliverShipment){
if(loadAtPrevAct + Math.abs(newAct.getCapacityDemand()) > iFacts.getNewVehicle().getCapacity()){
return ConstraintsStatus.NOT_FULFILLED_BREAK;
}
}
return ConstraintsStatus.FULFILLED;
}
}

13
jsprit-core/src/main/java/algorithms/ServiceBackhaulConstraint.java
View file

@ -1,19 +1,18 @@
package algorithms; package algorithms;
import basics.route.DeliveryActivity; import basics.route.DeliverService;
import basics.route.PickupActivity; import basics.route.PickupService;
import basics.route.ServiceActivity; import basics.route.ServiceActivity;
import basics.route.Start;
import basics.route.TourActivity; import basics.route.TourActivity;
public class ServiceBackhaulConstraint implements HardActivityStateLevelConstraint { public class ServiceBackhaulConstraint implements HardActivityStateLevelConstraint {
@Override @Override
public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) { public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
if(newAct instanceof PickupActivity && nextAct instanceof DeliveryActivity){ return ConstraintsStatus.NOT_FULFILLED; } if(newAct instanceof PickupService && nextAct instanceof DeliverService){ return ConstraintsStatus.NOT_FULFILLED; }
if(newAct instanceof ServiceActivity && nextAct instanceof DeliveryActivity){ return ConstraintsStatus.NOT_FULFILLED; } if(newAct instanceof ServiceActivity && nextAct instanceof DeliverService){ return ConstraintsStatus.NOT_FULFILLED; }
if(newAct instanceof DeliveryActivity && prevAct instanceof PickupActivity){ return ConstraintsStatus.NOT_FULFILLED; } if(newAct instanceof DeliverService && prevAct instanceof PickupService){ return ConstraintsStatus.NOT_FULFILLED_BREAK; }
if(newAct instanceof DeliveryActivity && prevAct instanceof ServiceActivity){ return ConstraintsStatus.NOT_FULFILLED; } if(newAct instanceof DeliverService && prevAct instanceof ServiceActivity){ return ConstraintsStatus.NOT_FULFILLED_BREAK; }
return ConstraintsStatus.FULFILLED; return ConstraintsStatus.FULFILLED;
} }

40
jsprit-core/src/main/java/algorithms/ServiceLoadActivityLevelConstraint.java
View file

@ -1,7 +1,9 @@
package algorithms; package algorithms;
import basics.route.DeliveryActivity; import org.apache.log4j.Logger;
import basics.route.PickupActivity;
import basics.route.DeliverService;
import basics.route.PickupService;
import basics.route.ServiceActivity; import basics.route.ServiceActivity;
import basics.route.Start; import basics.route.Start;
import basics.route.TourActivity; import basics.route.TourActivity;
@ -17,6 +19,8 @@ import basics.route.TourActivity;
*/ */
class ServiceLoadActivityLevelConstraint implements HardActivityStateLevelConstraint { class ServiceLoadActivityLevelConstraint implements HardActivityStateLevelConstraint {
private static Logger log = Logger.getLogger(ServiceLoadActivityLevelConstraint.class);
private StateGetter stateManager; private StateGetter stateManager;
public ServiceLoadActivityLevelConstraint(StateGetter stateManager) { public ServiceLoadActivityLevelConstraint(StateGetter stateManager) {
@ -26,31 +30,31 @@ class ServiceLoadActivityLevelConstraint implements HardActivityStateLevelConstr
@Override @Override
public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) { public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
int loadAtPrevAct; int futureMaxLoad;
int futurePicks; int prevMaxLoad;
int pastDeliveries;
if(prevAct instanceof Start){ if(prevAct instanceof Start){
loadAtPrevAct = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.LOAD_AT_BEGINNING).toDouble(); futureMaxLoad = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.MAXLOAD).toDouble();
futurePicks = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.LOAD_AT_END).toDouble(); prevMaxLoad = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.LOAD_AT_BEGINNING).toDouble();
pastDeliveries = 0;
} }
else{ else{
loadAtPrevAct = (int) stateManager.getActivityState(prevAct, StateFactory.LOAD).toDouble(); futureMaxLoad = (int) stateManager.getActivityState(prevAct, StateFactory.FUTURE_PICKS).toDouble();
futurePicks = (int) stateManager.getActivityState(prevAct, StateFactory.FUTURE_PICKS).toDouble(); prevMaxLoad = (int) stateManager.getActivityState(prevAct, StateFactory.PAST_DELIVERIES).toDouble();
pastDeliveries = (int) stateManager.getActivityState(prevAct, StateFactory.PAST_DELIVERIES).toDouble();
} }
if(newAct instanceof PickupActivity || newAct instanceof ServiceActivity){ if(newAct instanceof PickupService || newAct instanceof ServiceActivity){
if(loadAtPrevAct + newAct.getCapacityDemand() + futurePicks > iFacts.getNewVehicle().getCapacity()){ if(newAct.getCapacityDemand() + futureMaxLoad > iFacts.getNewVehicle().getCapacity()){
// log.debug("insertionOf("+newAct+").BETWEEN("+prevAct+").AND("+nextAct+")=NOT_POSSIBLE");
return ConstraintsStatus.NOT_FULFILLED; return ConstraintsStatus.NOT_FULFILLED;
} }
} }
if(newAct instanceof DeliveryActivity){ if(newAct instanceof DeliverService){
if(loadAtPrevAct + Math.abs(newAct.getCapacityDemand()) + pastDeliveries > iFacts.getNewVehicle().getCapacity()){ if(Math.abs(newAct.getCapacityDemand()) + prevMaxLoad > iFacts.getNewVehicle().getCapacity()){
return ConstraintsStatus.NOT_FULFILLED; // log.debug("insertionOf("+newAct+").BETWEEN("+prevAct+").AND("+nextAct+")=NOT_POSSIBLE[break=neverBePossibleAnymore]");
return ConstraintsStatus.NOT_FULFILLED_BREAK;
} }
} }
// log.debug("insertionOf("+newAct+").BETWEEN("+prevAct+").AND("+nextAct+")=POSSIBLE");
return ConstraintsStatus.FULFILLED; return ConstraintsStatus.FULFILLED;
} }
} }

16
jsprit-core/src/main/java/algorithms/ShipmentPickupsFirstConstraint.java Normal file
View file

@ -0,0 +1,16 @@
package algorithms;
import basics.route.DeliverShipment;
import basics.route.PickupShipment;
import basics.route.TourActivity;
public class ShipmentPickupsFirstConstraint implements HardActivityStateLevelConstraint {
@Override
public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
if(newAct instanceof DeliverShipment && nextAct instanceof PickupShipment){ return ConstraintsStatus.NOT_FULFILLED; }
if(newAct instanceof PickupShipment && prevAct instanceof DeliverShipment){ return ConstraintsStatus.NOT_FULFILLED_BREAK; }
return ConstraintsStatus.FULFILLED;
}
}

1
jsprit-core/src/main/java/algorithms/UpdateActivityTimes.java
View file

@ -3,7 +3,6 @@ package algorithms;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.ActivityTimeTracker; import util.ActivityTimeTracker;
import basics.costs.ForwardTransportTime; import basics.costs.ForwardTransportTime;
import basics.route.ActivityVisitor; import basics.route.ActivityVisitor;
import basics.route.TourActivity; import basics.route.TourActivity;

39
jsprit-core/src/main/java/algorithms/UpdateFuturePickups.java
View file

@ -1,39 +0,0 @@
package algorithms;
import basics.route.PickupActivity;
import basics.route.ReverseActivityVisitor;
import basics.route.ServiceActivity;
import basics.route.TourActivity;
import basics.route.VehicleRoute;
class UpdateFuturePickups implements ReverseActivityVisitor, StateUpdater {
private StateManager stateManager;
private int futurePicks = 0;
private VehicleRoute route;
public UpdateFuturePickups(StateManager stateManager) {
super();
this.stateManager = stateManager;
}
@Override
public void begin(VehicleRoute route) {
this.route = route;
}
@Override
public void visit(TourActivity act) {
stateManager.putActivityState(act, StateFactory.FUTURE_PICKS, StateFactory.createState(futurePicks));
if(act instanceof PickupActivity || act instanceof ServiceActivity){
futurePicks += act.getCapacityDemand();
}
assert futurePicks <= route.getVehicle().getCapacity() : "sum of pickups must not be > vehicleCap";
assert futurePicks >= 0 : "sum of pickups must not < 0";
}
@Override
public void finish() {
futurePicks = 0;
route = null;
}
}

14
jsprit-core/src/main/java/algorithms/UpdateLoads.java
View file

@ -2,6 +2,8 @@ package algorithms;
import java.util.Collection; import java.util.Collection;
import org.apache.log4j.Logger;
import basics.Delivery; import basics.Delivery;
import basics.Job; import basics.Job;
import basics.Pickup; import basics.Pickup;
@ -27,6 +29,7 @@ class UpdateLoads implements ActivityVisitor, StateUpdater, InsertionStartsListe
private StateManager stateManager; private StateManager stateManager;
private int currentLoad = 0; private int currentLoad = 0;
private VehicleRoute route; private VehicleRoute route;
private static Logger log = Logger.getLogger(UpdateLoads.class);
/** /**
* Updates load at activity level. * Updates load at activity level.
@ -89,6 +92,8 @@ class UpdateLoads implements ActivityVisitor, StateUpdater, InsertionStartsListe
@Override @Override
public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
// log.debug("insert("+job2insert+").into("+inRoute+")");
// log(inRoute);
if(job2insert instanceof Delivery){ if(job2insert instanceof Delivery){
int loadAtDepot = (int) stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING).toDouble(); int loadAtDepot = (int) stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING).toDouble();
// log.info("loadAtDepot="+loadAtDepot); // log.info("loadAtDepot="+loadAtDepot);
@ -101,4 +106,13 @@ class UpdateLoads implements ActivityVisitor, StateUpdater, InsertionStartsListe
} }
} }
// private void log(VehicleRoute inRoute) {
// log.debug(inRoute.getStart());
// for(TourActivity act : inRoute.getTourActivities().getActivities()){
// log.debug(act);
// }
// log.debug(inRoute.getEnd());
//
// }
} }

61
jsprit-core/src/main/java/algorithms/UpdateMaxLoad.java
View file

@ -1,67 +1,44 @@
package algorithms; package algorithms;
import basics.route.ActivityVisitor; import org.apache.log4j.Logger;
import basics.route.ReverseActivityVisitor;
import basics.route.TourActivity; import basics.route.TourActivity;
import basics.route.VehicleRoute; import basics.route.VehicleRoute;
/** class UpdateMaxLoad implements ReverseActivityVisitor, StateUpdater {
* Updates load at activity level. private static Logger log = Logger.getLogger(UpdateMaxLoad.class);
*
* <p>Note that this assumes that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT.
* If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot.
*
* <p>Thus it DEPENDS on StateTypes.LOAD_AT_DEPOT
*
* @author stefan
*
*/
class UpdateMaxLoad implements ActivityVisitor, StateUpdater {
private StateManager stateManager; private StateManager stateManager;
private int currentLoad = 0;
private VehicleRoute route; private VehicleRoute route;
private int maxLoad = 0; private double maxLoad;
private double currLoad;
/**
* Updates load at activity level.
*
* <p>Note that this assumes that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT.
* If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot.
*
* <p>Thus it DEPENDS on StateTypes.LOAD_AT_DEPOT
*
*
*
* <p>The loads can be retrieved by <br>
* <code>stateManager.getActivityState(activity,StateTypes.LOAD);</code>
*
*
* @author stefan
*
*/
public UpdateMaxLoad(StateManager stateManager) { public UpdateMaxLoad(StateManager stateManager) {
super(); super();
this.stateManager = stateManager; this.stateManager = stateManager;
} }
@Override @Override
public void begin(VehicleRoute route) { public void begin(VehicleRoute route) {
currentLoad = (int) stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble();
maxLoad = currentLoad;
this.route = route; this.route = route;
maxLoad = stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble();
// currLoad = maxLoad;
// log.debug("maxLoad@end="+maxLoad);
} }
@Override @Override
public void visit(TourActivity act) { public void visit(TourActivity act) {
currentLoad += act.getCapacityDemand(); maxLoad = Math.max(maxLoad, stateManager.getActivityState(act, StateFactory.LOAD).toDouble());
maxLoad = Math.max(maxLoad, currentLoad); // currLoad -= act.getCapacityDemand();
assert currentLoad <= route.getVehicle().getCapacity() : "currentLoad at activity must not be > vehicleCapacity"; // log.debug("maxLoad@"+act+"="+maxLoad);
assert currentLoad >= 0 : "currentLoad at act must not be < 0"; stateManager.putActivityState(act, StateFactory.FUTURE_PICKS, StateFactory.createState(maxLoad));
assert maxLoad <= route.getVehicle().getCapacity() : "maxLoad can never be bigger than vehicleCap";
assert maxLoad >= 0 : "maxLoad can never be smaller than 0";
} }
@Override @Override
public void finish() { public void finish() {
stateManager.putRouteState(route, StateFactory.MAXLOAD, StateFactory.createState(maxLoad)); // stateManager.putRouteState(route, StateFactory.MAXLOAD, StateFactory.createState(maxLoad));
currentLoad = 0; // log.debug("maxLoad@start="+maxLoad);
maxLoad = 0;
} }
} }

67
jsprit-core/src/main/java/algorithms/UpdateMaxLoad_.java Normal file
View file

@ -0,0 +1,67 @@
package algorithms;
import basics.route.ActivityVisitor;
import basics.route.TourActivity;
import basics.route.VehicleRoute;
/**
* Updates load at activity level.
*
* <p>Note that this assumes that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT.
* If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot.
*
* <p>Thus it DEPENDS on StateTypes.LOAD_AT_DEPOT
*
* @author stefan
*
*/
class UpdateMaxLoad_ implements ActivityVisitor, StateUpdater {
private StateManager stateManager;
private int currentLoad = 0;
private VehicleRoute route;
private int maxLoad = 0;
/**
* Updates load at activity level.
*
* <p>Note that this assumes that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT.
* If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot.
*
* <p>Thus it DEPENDS on StateTypes.LOAD_AT_DEPOT
*
*
*
* <p>The loads can be retrieved by <br>
* <code>stateManager.getActivityState(activity,StateTypes.LOAD);</code>
*
*
* @author stefan
*
*/
public UpdateMaxLoad_(StateManager stateManager) {
super();
this.stateManager = stateManager;
}
@Override
public void begin(VehicleRoute route) {
currentLoad = (int) stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble();
maxLoad = currentLoad;
this.route = route;
}
@Override
public void visit(TourActivity act) {
currentLoad += act.getCapacityDemand();
maxLoad = Math.max(maxLoad, currentLoad);
assert currentLoad <= route.getVehicle().getCapacity() : "currentLoad at activity must not be > vehicleCapacity";
assert currentLoad >= 0 : "currentLoad at act must not be < 0";
}
@Override
public void finish() {
stateManager.putRouteState(route, StateFactory.MAXLOAD, StateFactory.createState(maxLoad));
currentLoad = 0;
maxLoad = 0;
}
}

38
jsprit-core/src/main/java/algorithms/UpdateOccuredDeliveries.java
View file

@ -1,38 +0,0 @@
package algorithms;
import basics.route.ActivityVisitor;
import basics.route.DeliveryActivity;
import basics.route.TourActivity;
import basics.route.VehicleRoute;
class UpdateOccuredDeliveries implements ActivityVisitor, StateUpdater {
private StateManager stateManager;
private int deliveries = 0;
private VehicleRoute route;
public UpdateOccuredDeliveries(StateManager stateManager) {
super();
this.stateManager = stateManager;
}
@Override
public void begin(VehicleRoute route) {
this.route = route;
}
@Override
public void visit(TourActivity act) {
if(act instanceof DeliveryActivity){
deliveries += Math.abs(act.getCapacityDemand());
}
stateManager.putActivityState(act, StateFactory.PAST_DELIVERIES, StateFactory.createState(deliveries));
assert deliveries >= 0 : "deliveries < 0";
assert deliveries <= route.getVehicle().getCapacity() : "deliveries > vehicleCap";
}
@Override
public void finish() {
deliveries = 0;
route = null;
}
}

42
jsprit-core/src/main/java/algorithms/UpdatePrevMaxLoad.java Normal file
View file

@ -0,0 +1,42 @@
package algorithms;
import org.apache.log4j.Logger;
import basics.route.ActivityVisitor;
import basics.route.TourActivity;
import basics.route.VehicleRoute;
class UpdatePrevMaxLoad implements ActivityVisitor, StateUpdater {
private static Logger log = Logger.getLogger(UpdatePrevMaxLoad.class);
private StateManager stateManager;
private VehicleRoute route;
private double currLoad;
private double prevMaxLoad;
public UpdatePrevMaxLoad(StateManager stateManager) {
super();
this.stateManager = stateManager;
}
@Override
public void begin(VehicleRoute route) {
this.route = route;
currLoad = stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble();
prevMaxLoad = currLoad;
// log.debug("prevMaxLoad@start="+prevMaxLoad);
}
@Override
public void visit(TourActivity act) {
prevMaxLoad = Math.max(prevMaxLoad, stateManager.getActivityState(act, StateFactory.LOAD).toDouble());
// log.debug("prevMaxLoad@"+act+"="+prevMaxLoad);
stateManager.putActivityState(act, StateFactory.PAST_DELIVERIES, StateFactory.createState(prevMaxLoad));
assert prevMaxLoad >= 0 : "maxLoad can never be smaller than 0";
assert prevMaxLoad <= route.getVehicle().getCapacity() : "maxLoad can never be bigger than vehicleCap";
}
@Override
public void finish() {
// log.debug("prevMaxLoad@end="+prevMaxLoad);
}
}

2
jsprit-core/src/main/java/algorithms/UpdateVariableCosts.java
View file

@ -3,14 +3,12 @@ package algorithms;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.ActivityTimeTracker; import util.ActivityTimeTracker;
import algorithms.StateManager.StateImpl; import algorithms.StateManager.StateImpl;
import basics.costs.ForwardTransportCost; import basics.costs.ForwardTransportCost;
import basics.costs.VehicleRoutingActivityCosts; import basics.costs.VehicleRoutingActivityCosts;
import basics.costs.VehicleRoutingTransportCosts; import basics.costs.VehicleRoutingTransportCosts;
import basics.route.ActivityVisitor; import basics.route.ActivityVisitor;
import basics.route.TourActivity; import basics.route.TourActivity;
import basics.route.Vehicle;
import basics.route.VehicleRoute; import basics.route.VehicleRoute;
/** /**

6
jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithmFactoryImpl.java
View file

@ -25,8 +25,12 @@ public class VehicleRoutingAlgorithmFactoryImpl implements VehicleRoutingAlgorit
@Override @Override
public VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vrp) { public VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vrp) {
this.stateManager.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), this.stateManager)); this.stateManager.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), this.stateManager));
this.stateManager.addActivityVisitor(new UpdateMaxLoad(this.stateManager)); //<<<<<<< HEAD
// this.stateManager.addActivityVisitor(new UpdateMaxLoad(this.stateManager));
this.stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts())); this.stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
//=======
//// this.stateManager.addActivityVisitor(new UpdateMaxLoad_(this.stateManager));
//>>>>>>> refs/heads/pickupAndDelivery
VehicleRoutingAlgorithm algorithm = new VehicleRoutingAlgorithm(vrp, searchStrategyManager); VehicleRoutingAlgorithm algorithm = new VehicleRoutingAlgorithm(vrp, searchStrategyManager);
algorithm.getAlgorithmListeners().addListener(stateManager); algorithm.getAlgorithmListeners().addListener(stateManager);
algorithm.getSearchStrategyManager().addSearchStrategyModuleListener(stateManager); algorithm.getSearchStrategyManager().addSearchStrategyModuleListener(stateManager);

34
jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithms.java
View file

@ -46,7 +46,6 @@ import algorithms.selectors.SelectRandomly;
import algorithms.selectors.SolutionSelector; import algorithms.selectors.SolutionSelector;
import basics.VehicleRoutingAlgorithm; import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem; import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblem.Constraint;
import basics.VehicleRoutingProblem.FleetSize; import basics.VehicleRoutingProblem.FleetSize;
import basics.VehicleRoutingProblemSolution; import basics.VehicleRoutingProblemSolution;
import basics.algo.AlgorithmStartsListener; import basics.algo.AlgorithmStartsListener;
@ -446,16 +445,8 @@ public class VehicleRoutingAlgorithms {
*/ */
//constraint manager //constraint manager
ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
constraintManager.addConstraint(new TimeWindowConstraint(stateManager, vrp.getTransportCosts())); constraintManager.addTimeWindowConstraint();
constraintManager.addLoadConstraint();
if(vrp.getProblemConstraints().contains(Constraint.DELIVERIES_FIRST)){
constraintManager.addConstraint(new ServiceBackhaulConstraint());
}
else{
constraintManager.addConstraint(new ServiceLoadActivityLevelConstraint(stateManager));
}
constraintManager.addConstraint(new ServiceLoadRouteLevelConstraint(stateManager));
//construct initial solution creator //construct initial solution creator
AlgorithmStartsListener createInitialSolution = createInitialSolution(config,vrp,vehicleFleetManager,stateManager,algorithmListeners,definedClasses,executorService,nuOfThreads,constraintManager); AlgorithmStartsListener createInitialSolution = createInitialSolution(config,vrp,vehicleFleetManager,stateManager,algorithmListeners,definedClasses,executorService,nuOfThreads,constraintManager);
@ -492,24 +483,15 @@ public class VehicleRoutingAlgorithms {
/* /*
* define stateUpdates * define stateUpdates
*/ */
// UpdateLoads loadUpdater = new UpdateLoads(stateManager);
// stateManager.addListener(new UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts(stateManager)); // stateManager.addListener(loadUpdater);
// stateManager.addListener(new UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted(stateManager)); // stateManager.addActivityVisitor(loadUpdater);
//
UpdateLoads loadUpdater = new UpdateLoads(stateManager);
stateManager.addListener(loadUpdater);
stateManager.addActivityVisitor(loadUpdater);
stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts())); stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
stateManager.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager)); stateManager.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
stateManager.addActivityVisitor(new UpdateOccuredDeliveries(stateManager)); // stateManager.addActivityVisitor(new UpdateOccuredDeliveries(stateManager));
stateManager.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts())); // stateManager.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts()));
stateManager.addActivityVisitor(new UpdateFuturePickups(stateManager)); // stateManager.addActivityVisitor(new UpdateFuturePickups(stateManager));
metaAlgorithm.getSearchStrategyManager().addSearchStrategyModuleListener(stateManager); metaAlgorithm.getSearchStrategyManager().addSearchStrategyModuleListener(stateManager);
metaAlgorithm.getAlgorithmListeners().addListener(stateManager); metaAlgorithm.getAlgorithmListeners().addListener(stateManager);

2
jsprit-core/src/main/java/basics/Service.java
View file

@ -139,7 +139,7 @@ public class Service implements Job {
@Override @Override
public String toString() { public String toString() {
return "[id=" + id + "][locationId=" + locationId + "][coord="+coord+"][size=" + demand + "][serviceTime=" + serviceTime + "][timeWindow=" + timeWindow + "]"; return "[id=" + id + "][type="+type+"][locationId=" + locationId + "][coord="+coord+"][size=" + demand + "][serviceTime=" + serviceTime + "][timeWindow=" + timeWindow + "]";
} }
/* (non-Javadoc) /* (non-Javadoc)

2
jsprit-core/src/main/java/basics/route/DeliverService.java
View file

@ -83,6 +83,6 @@ public final class DeliverService implements DeliveryActivity{
@Override @Override
public String toString() { public String toString() {
return "[act="+getName()+"][loc="+getLocationId()+"]"; return "[act="+getName()+"][capDemand="+getCapacityDemand()+"][loc="+getLocationId()+"]";
} }
} }

1
jsprit-core/src/main/java/basics/route/DeliveryActivity.java
View file

@ -16,7 +16,6 @@
******************************************************************************/ ******************************************************************************/
package basics.route; package basics.route;
import basics.Delivery;
import basics.route.TourActivity.JobActivity; import basics.route.TourActivity.JobActivity;
public interface DeliveryActivity extends JobActivity{ public interface DeliveryActivity extends JobActivity{

2
jsprit-core/src/main/java/basics/route/PickupService.java
View file

@ -88,7 +88,7 @@ public final class PickupService implements PickupActivity{
@Override @Override
public String toString() { public String toString() {
return "[act="+getName()+"][loc="+getLocationId()+"]"; return "[act="+getName()+"][capDemand="+getCapacityDemand()+"][loc="+getLocationId()+"]";
} }
} }

100
jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java
View file

@ -23,24 +23,16 @@ import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import util.Solutions; import util.Solutions;
import algorithms.StateManager.StateImpl;
import algorithms.acceptors.AcceptNewIfBetterThanWorst; import algorithms.acceptors.AcceptNewIfBetterThanWorst;
import algorithms.selectors.SelectBest; import algorithms.selectors.SelectBest;
import basics.Delivery;
import basics.Job;
import basics.Pickup;
import basics.VehicleRoutingAlgorithm; import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem; import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution; import basics.VehicleRoutingProblemSolution;
import basics.algo.InsertionStartsListener;
import basics.algo.JobInsertedListener;
import basics.algo.SearchStrategy; import basics.algo.SearchStrategy;
import basics.algo.SearchStrategyManager; import basics.algo.SearchStrategyManager;
import basics.algo.SolutionCostCalculator; import basics.algo.SolutionCostCalculator;
import basics.io.VrpXMLReader; import basics.io.VrpXMLReader;
import basics.route.InfiniteFleetManagerFactory; import basics.route.InfiniteFleetManagerFactory;
import basics.route.ReverseRouteActivityVisitor;
import basics.route.RouteActivityVisitor;
import basics.route.VehicleFleetManager; import basics.route.VehicleFleetManager;
import basics.route.VehicleRoute; import basics.route.VehicleRoute;
@ -61,22 +53,16 @@ public class BuildPDVRPAlgoFromScratchTest {
final StateManager stateManager = new StateManager(); final StateManager stateManager = new StateManager();
ConstraintManager actLevelConstraintAccumulator = new ConstraintManager(vrp,stateManager); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
actLevelConstraintAccumulator.addConstraint(new ServiceLoadActivityLevelConstraint(stateManager)); constraintManager.addTimeWindowConstraint();
actLevelConstraintAccumulator.addConstraint(new TimeWindowConstraint(stateManager, vrp.getTransportCosts())); constraintManager.addLoadConstraint();
ActivityInsertionCostsCalculator marginalCalculus = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts());
ServiceInsertionCalculator serviceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), marginalCalculus, new ServiceLoadRouteLevelConstraint(stateManager), actLevelConstraintAccumulator);
// CalculatesServiceInsertion serviceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), marginalCalculus, new HardConstraints.HardLoadConstraint(stateManager));
VehicleFleetManager fleetManager = new InfiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager(); VehicleFleetManager fleetManager = new InfiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
JobInsertionCostsCalculator finalServiceInsertion = new VehicleTypeDependentJobInsertionCalculator(fleetManager, serviceInsertion);
BestInsertion bestInsertion = new BestInsertion(finalServiceInsertion);
BestInsertionBuilder iBuilder = new BestInsertionBuilder(vrp, fleetManager, stateManager, constraintManager);
// iBuilder.setConstraintManager(constraintManger);
InsertionStrategy bestInsertion = iBuilder.build();
RuinRadial radial = new RuinRadial(vrp, 0.15, new JobDistanceAvgCosts(vrp.getTransportCosts())); RuinRadial radial = new RuinRadial(vrp, 0.15, new JobDistanceAvgCosts(vrp.getTransportCosts()));
RuinRandom random = new RuinRandom(vrp, 0.25); RuinRandom random = new RuinRandom(vrp, 0.25);
@ -104,80 +90,14 @@ public class BuildPDVRPAlgoFromScratchTest {
strategyManager.addStrategy(radialStrategy, 0.5); strategyManager.addStrategy(radialStrategy, 0.5);
strategyManager.addStrategy(randomStrategy, 0.5); strategyManager.addStrategy(randomStrategy, 0.5);
vra = new VehicleRoutingAlgorithm(vrp, strategyManager); vra = new VehicleRoutingAlgorithmFactoryImpl(strategyManager, stateManager, fleetManager).createAlgorithm(vrp);
vra.getAlgorithmListeners().addListener(stateManager);
final RouteActivityVisitor iterateForward = new RouteActivityVisitor();
iterateForward.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
// iterateForward.addActivityVisitor(new UpdateEarliestStartTime(stateManager, vrp.getTransportCosts()));
iterateForward.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
iterateForward.addActivityVisitor(new UpdateOccuredDeliveries(stateManager));
iterateForward.addActivityVisitor(new UpdateLoads(stateManager));
final ReverseRouteActivityVisitor iterateBackward = new ReverseRouteActivityVisitor();
iterateBackward.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts()));
iterateBackward.addActivityVisitor(new UpdateFuturePickups(stateManager));
InsertionStartsListener loadVehicleInDepot = new InsertionStartsListener() {
@Override
public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
for(VehicleRoute route : vehicleRoutes){
int loadAtDepot = 0;
int loadAtEnd = 0;
for(Job j : route.getTourActivities().getJobs()){
if(j instanceof Delivery){
loadAtDepot += j.getCapacityDemand();
}
if(j instanceof Pickup){
loadAtEnd += j.getCapacityDemand();
}
}
stateManager.putRouteState(route, StateFactory.LOAD_AT_BEGINNING, new StateImpl(loadAtDepot));
stateManager.putRouteState(route, StateFactory.LOAD, new StateImpl(loadAtEnd));
iterateForward.visit(route);
iterateBackward.visit(route);
}
}
};
vra.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager));
JobInsertedListener updateLoadAfterJobHasBeenInserted = new JobInsertedListener() {
@Override
public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
// log.info("insert job " + job2insert.getClass().toString() + " job " + job2insert + "" + job2insert.getCapacityDemand() + " in route " + inRoute.getTourActivities());
if(job2insert instanceof Delivery){
int loadAtDepot = (int) stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING).toDouble();
// log.info("loadAtDepot="+loadAtDepot);
stateManager.putRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING, StateFactory.createState(loadAtDepot + job2insert.getCapacityDemand()));
}
if(job2insert instanceof Pickup){
int loadAtEnd = (int) stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_END).toDouble();
// log.info("loadAtEnd="+loadAtEnd);
stateManager.putRouteState(inRoute, StateFactory.LOAD_AT_END, StateFactory.createState(loadAtEnd + job2insert.getCapacityDemand()));
}
iterateForward.visit(inRoute);
iterateBackward.visit(inRoute);
}
};
bestInsertion.addListener(loadVehicleInDepot);
bestInsertion.addListener(updateLoadAfterJobHasBeenInserted);
VehicleRoutingProblemSolution iniSolution = new InsertionInitialSolutionFactory(bestInsertion, solutionCostCalculator).createSolution(vrp); VehicleRoutingProblemSolution iniSolution = new InsertionInitialSolutionFactory(bestInsertion, solutionCostCalculator).createSolution(vrp);
// System.out.println("ini: costs="+iniSolution.getCost()+";#routes="+iniSolution.getRoutes().size()); // System.out.println("ini: costs="+iniSolution.getCost()+";#routes="+iniSolution.getRoutes().size());
vra.addInitialSolution(iniSolution); vra.addInitialSolution(iniSolution);
vra.setNuOfIterations(10000); vra.setNuOfIterations(1000);
vra.setPrematureBreak(1000); vra.setPrematureBreak(100);
} }

66
jsprit-core/src/test/java/algorithms/BuildPDVRPWithShipmentsAlgoFromScratchTest.java
View file

@ -80,7 +80,7 @@ public class BuildPDVRPWithShipmentsAlgoFromScratchTest {
ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
constraintManager.addTimeWindowConstraint(); constraintManager.addTimeWindowConstraint();
constraintManager.addLoadConstraint(); constraintManager.addLoadConstraint();
constraintManager.addConstraint(new HardPickupAndDeliveryShipmentActivityLevelConstraint(stateManager,true)); // constraintManager.addConstraint(new HardPickupAndDeliveryShipmentActivityLevelConstraint(stateManager));
VehicleFleetManager fleetManager = new InfiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager(); VehicleFleetManager fleetManager = new InfiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
@ -88,6 +88,7 @@ public class BuildPDVRPWithShipmentsAlgoFromScratchTest {
executorService = Executors.newFixedThreadPool(nuOfThreads); executorService = Executors.newFixedThreadPool(nuOfThreads);
BestInsertionBuilder bestIBuilder = new BestInsertionBuilder(vrp, fleetManager, stateManager,constraintManager); BestInsertionBuilder bestIBuilder = new BestInsertionBuilder(vrp, fleetManager, stateManager,constraintManager);
bestIBuilder.setConcurrentMode(executorService, nuOfThreads); bestIBuilder.setConcurrentMode(executorService, nuOfThreads);
InsertionStrategy bestInsertion = bestIBuilder.build(); InsertionStrategy bestInsertion = bestIBuilder.build();
@ -139,20 +140,58 @@ public class BuildPDVRPWithShipmentsAlgoFromScratchTest {
strategyManager.addStrategy(randomStrategy, 0.5); strategyManager.addStrategy(randomStrategy, 0.5);
vra = new VehicleRoutingAlgorithmFactoryImpl(strategyManager, stateManager, fleetManager).createAlgorithm(vrp); vra = new VehicleRoutingAlgorithmFactoryImpl(strategyManager, stateManager, fleetManager).createAlgorithm(vrp);
// vra.getAlgorithmListeners().addListener(stateManager);
// final RouteActivityVisitor iterateForward = new RouteActivityVisitor();
// iterateForward.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
// iterateForward.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
// //
// iterateForward.addActivityVisitor(new UpdateOccuredDeliveries(stateManager)); //// vra.getAlgorithmListeners().addListener(stateManager);
//
//// final RouteActivityVisitor iterateForward = new RouteActivityVisitor();
//
//// iterateForward.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
//// iterateForward.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
////
//// iterateForward.addActivityVisitor(new UpdateOccuredDeliveries(stateManager));
//// iterateForward.addActivityVisitor(new UpdateLoads(stateManager));
////
//// final ReverseRouteActivityVisitor iterateBackward = new ReverseRouteActivityVisitor();
//// iterateBackward.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts()));
//// iterateBackward.addActivityVisitor(new UpdateFuturePickups(stateManager));
////
//// JobInsertedListener updateWhenJobHasBeenInserted = new JobInsertedListener() {
////
//// @Override
//// public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
//// iterateForward.visit(inRoute);
//// iterateBackward.visit(inRoute);
//// }
////
//// };
////
//// InsertionStartsListener updateRoutesWhenInsertionStarts = new InsertionStartsListener() {
////
//// @Override
//// public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
//// for(VehicleRoute route : vehicleRoutes){
//// iterateForward.visit(route);
//// iterateBackward.visit(route);
//// }
////
//// }
//// };
//
//<<<<<<< HEAD
//// vra.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager));
//=======
// iterateForward.addActivityVisitor(new UpdatePrevMaxLoad(stateManager));
// iterateForward.addActivityVisitor(new UpdateLoads(stateManager)); // iterateForward.addActivityVisitor(new UpdateLoads(stateManager));
//>>>>>>> branch 'PickupAndDelivery' of https://github.com/jsprit/jsprit.git
// //
//<<<<<<< HEAD
//// bestInsertion.addListener(new UpdateLoads(stateManager));
//// bestInsertion.addListener(updateWhenJobHasBeenInserted);
//// bestInsertion.addListener(updateRoutesWhenInsertionStarts);
//=======
// final ReverseRouteActivityVisitor iterateBackward = new ReverseRouteActivityVisitor(); // final ReverseRouteActivityVisitor iterateBackward = new ReverseRouteActivityVisitor();
// iterateBackward.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts())); // iterateBackward.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts()));
// iterateBackward.addActivityVisitor(new UpdateFuturePickups(stateManager)); // iterateBackward.addActivityVisitor(new UpdateMaxLoad(stateManager));
// //
// JobInsertedListener updateWhenJobHasBeenInserted = new JobInsertedListener() { // JobInsertedListener updateWhenJobHasBeenInserted = new JobInsertedListener() {
// //
@ -175,13 +214,14 @@ public class BuildPDVRPWithShipmentsAlgoFromScratchTest {
// //
// } // }
// }; // };
//
// vra.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager)); // vra.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager));
//
// bestInsertion.addListener(new UpdateLoads(stateManager)); // bestInsertion.addListener(new UpdateLoads(stateManager));
// bestInsertion.addListener(updateWhenJobHasBeenInserted); // bestInsertion.addListener(updateWhenJobHasBeenInserted);
// bestInsertion.addListener(updateRoutesWhenInsertionStarts); // bestInsertion.addListener(updateRoutesWhenInsertionStarts);
//>>>>>>> branch 'PickupAndDelivery' of https://github.com/jsprit/jsprit.git
//
VehicleRoutingProblemSolution iniSolution = new InsertionInitialSolutionFactory(bestInsertion, solutionCostCalculator).createSolution(vrp); VehicleRoutingProblemSolution iniSolution = new InsertionInitialSolutionFactory(bestInsertion, solutionCostCalculator).createSolution(vrp);
// System.out.println("ini: costs="+iniSolution.getCost()+";#routes="+iniSolution.getRoutes().size()); // System.out.println("ini: costs="+iniSolution.getCost()+";#routes="+iniSolution.getRoutes().size());
vra.addInitialSolution(iniSolution); vra.addInitialSolution(iniSolution);

4
jsprit-core/src/test/java/algorithms/HardPickupAndDeliveryShipmentActivityConstraintTest.java
View file

@ -23,7 +23,7 @@ public class HardPickupAndDeliveryShipmentActivityConstraintTest {
Shipment shipment; Shipment shipment;
HardPickupAndDeliveryShipmentActivityLevelConstraint constraint; PickupAndDeliverShipmentLoadActivityLevelConstraint constraint;
InsertionContext iFacts; InsertionContext iFacts;
@ -35,7 +35,7 @@ public class HardPickupAndDeliveryShipmentActivityConstraintTest {
shipment = mock(Shipment.class); shipment = mock(Shipment.class);
when(shipment.getCapacityDemand()).thenReturn(1); when(shipment.getCapacityDemand()).thenReturn(1);
iFacts = new InsertionContext(null, null, vehicle, null, 0.0); iFacts = new InsertionContext(null, null, vehicle, null, 0.0);
constraint = new HardPickupAndDeliveryShipmentActivityLevelConstraint(stateManager); constraint = new PickupAndDeliverShipmentLoadActivityLevelConstraint(stateManager);
} }
@Test @Test

135
jsprit-core/src/test/java/algorithms/ServiceInsertionAndLoadConstraintsTest.java Normal file
View file

@ -0,0 +1,135 @@
package algorithms;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import java.util.Arrays;
import org.junit.Before;
import org.junit.Test;
import util.Coordinate;
import util.Locations;
import util.ManhattanCosts;
import basics.Delivery;
import basics.Pickup;
import basics.Shipment;
import basics.VehicleRoutingProblem;
import basics.costs.VehicleRoutingActivityCosts;
import basics.costs.VehicleRoutingTransportCosts;
import basics.route.Driver;
import basics.route.DriverImpl;
import basics.route.TourActivity;
import basics.route.Vehicle;
import basics.route.VehicleImpl;
import basics.route.VehicleRoute;
import basics.route.VehicleType;
import basics.route.VehicleTypeImpl;
public class ServiceInsertionAndLoadConstraintsTest {
VehicleRoutingTransportCosts routingCosts;
VehicleRoutingActivityCosts activityCosts = new VehicleRoutingActivityCosts(){
@Override
public double getActivityCost(TourActivity tourAct, double arrivalTime,Driver driver, Vehicle vehicle) {
return 0;
}
};
HardActivityStateLevelConstraint hardActivityLevelConstraint = new HardActivityStateLevelConstraint() {
@Override
public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct,TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
return ConstraintsStatus.FULFILLED;
}
};
HardRouteStateLevelConstraint hardRouteLevelConstraint = new HardRouteStateLevelConstraint(){
@Override
public boolean fulfilled(InsertionContext insertionContext) {
return true;
}
};
ActivityInsertionCostsCalculator activityInsertionCostsCalculator;
ShipmentInsertionCalculator insertionCalculator;
Vehicle vehicle;
@Before
public void doBefore(){
Locations locations = new Locations(){
@Override
public Coordinate getCoord(String id) {
//assume: locationId="x,y"
String[] splitted = id.split(",");
return Coordinate.newInstance(Double.parseDouble(splitted[0]),
Double.parseDouble(splitted[1]));
}
};
routingCosts = new ManhattanCosts(locations);
VehicleType type = VehicleTypeImpl.Builder.newInstance("t", 2).setCostPerDistance(1).build();
vehicle = VehicleImpl.Builder.newInstance("v").setLocationId("0,0").setType(type).build();
activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts);
createInsertionCalculator(hardRouteLevelConstraint);
}
private void createInsertionCalculator(HardRouteStateLevelConstraint hardRouteLevelConstraint) {
insertionCalculator = new ShipmentInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, hardActivityLevelConstraint);
}
@Test
public void whenInsertingServiceWhileNoCapIsAvailable_itMustReturnTheCorrectInsertionIndex(){
Delivery delivery = (Delivery) Delivery.Builder.newInstance("del", 41).setLocationId("10,10").build();
Pickup pickup = (Pickup) Pickup.Builder.newInstance("pick", 15).setLocationId("0,10").build();
VehicleType type = VehicleTypeImpl.Builder.newInstance("t", 50).setCostPerDistance(1).build();
Vehicle vehicle = VehicleImpl.Builder.newInstance("v").setLocationId("0,0").setType(type).build();
VehicleRoute route = VehicleRoute.emptyRoute();
route.setVehicle(vehicle, 0.0);
Inserter inserter = new Inserter(new InsertionListeners());
inserter.insertJob(delivery, new InsertionData(0,0,0,vehicle,null), route);
// inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
// inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
StateManager stateManager = new StateManager();
// RouteActivityVisitor routeActVisitor = new RouteActivityVisitor();
// routeActVisitor.addActivityVisitor(new UpdateLoads(stateManager));
// routeActVisitor.visit(route);
VehicleRoutingProblem vrp = mock(VehicleRoutingProblem.class);
ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
constraintManager.addLoadConstraint();
// constraintManager.addConstraint(new PickupAndDeliverShipmentLoadActivityLevelConstraint(stateManager),Priority.CRITICAL);
// constraintManager.addConstraint(new ShipmentPickupsFirstConstraint(),Priority.CRITICAL);
stateManager.informInsertionStarts(Arrays.asList(route), null);
JobCalculatorSwitcher switcher = new JobCalculatorSwitcher();
ServiceInsertionCalculator serviceInsertionCalc = new ServiceInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, constraintManager);
ShipmentInsertionCalculator insertionCalculator = new ShipmentInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, constraintManager);
switcher.put(Pickup.class, serviceInsertionCalc);
switcher.put(Delivery.class, serviceInsertionCalc);
switcher.put(Shipment.class, insertionCalculator);
// Pickup service = (Pickup)Pickup.Builder.newInstance("pick", 1).setLocationId("5,5").build();
InsertionData iData = switcher.getInsertionData(route, pickup, vehicle, 0, DriverImpl.noDriver(), Double.MAX_VALUE);
// routeActVisitor.visit(route);
assertEquals(1, iData.getDeliveryInsertionIndex());
}
}

56
jsprit-core/src/test/java/algorithms/ShipmentInsertionCalculatorTest.java
View file

@ -2,9 +2,9 @@ package algorithms;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
@ -12,7 +12,8 @@ import org.junit.Test;
import util.Coordinate; import util.Coordinate;
import util.Locations; import util.Locations;
import util.ManhattanCosts; import util.ManhattanCosts;
import algorithms.HardActivityStateLevelConstraint.ConstraintsStatus; import algorithms.ConstraintManager.Priority;
import basics.Pickup;
import basics.Shipment; import basics.Shipment;
import basics.VehicleRoutingProblem; import basics.VehicleRoutingProblem;
import basics.costs.VehicleRoutingActivityCosts; import basics.costs.VehicleRoutingActivityCosts;
@ -188,8 +189,9 @@ public class ShipmentInsertionCalculatorTest {
VehicleRoutingProblem vrp = mock(VehicleRoutingProblem.class); VehicleRoutingProblem vrp = mock(VehicleRoutingProblem.class);
ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
constraintManager.addConstraint(new PickupAndDeliverShipmentLoadActivityLevelConstraint(stateManager),Priority.CRITICAL);
constraintManager.addConstraint(new HardPickupAndDeliveryShipmentActivityLevelConstraint(stateManager,true)); constraintManager.addConstraint(new ShipmentPickupsFirstConstraint(),Priority.CRITICAL);
ShipmentInsertionCalculator insertionCalculator = new ShipmentInsertionCalculator(routingCosts, activityInsertionCostsCalculator, ShipmentInsertionCalculator insertionCalculator = new ShipmentInsertionCalculator(routingCosts, activityInsertionCostsCalculator,
hardRouteLevelConstraint, constraintManager); hardRouteLevelConstraint, constraintManager);
@ -199,4 +201,48 @@ public class ShipmentInsertionCalculatorTest {
} }
@Test
public void whenInsertingServiceWhileNoCapIsAvailable_itMustReturnNoInsertionData(){
Shipment shipment = Shipment.Builder.newInstance("s", 1).setPickupLocation("0,10").setDeliveryLocation("0,0").build();
Shipment shipment2 = Shipment.Builder.newInstance("s2", 1).setPickupLocation("10,10").setDeliveryLocation("0,0").build();
Shipment shipment3 = Shipment.Builder.newInstance("s3", 1).setPickupLocation("10,10").setDeliveryLocation("0,").build();
VehicleRoute route = VehicleRoute.emptyRoute();
route.setVehicle(vehicle, 0.0);
Inserter inserter = new Inserter(new InsertionListeners());
inserter.insertJob(shipment, new InsertionData(0,0,0,vehicle,null), route);
inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
// inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
StateManager stateManager = new StateManager();
// RouteActivityVisitor routeActVisitor = new RouteActivityVisitor();
// routeActVisitor.addActivityVisitor(new UpdateLoads(stateManager));
// routeActVisitor.visit(route);
VehicleRoutingProblem vrp = mock(VehicleRoutingProblem.class);
ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
constraintManager.addLoadConstraint();
// constraintManager.addConstraint(new PickupAndDeliverShipmentLoadActivityLevelConstraint(stateManager),Priority.CRITICAL);
// constraintManager.addConstraint(new ShipmentPickupsFirstConstraint(),Priority.CRITICAL);
stateManager.informInsertionStarts(Arrays.asList(route), null);
JobCalculatorSwitcher switcher = new JobCalculatorSwitcher();
ServiceInsertionCalculator serviceInsertionCalc = new ServiceInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, constraintManager);
ShipmentInsertionCalculator insertionCalculator = new ShipmentInsertionCalculator(routingCosts, activityInsertionCostsCalculator, hardRouteLevelConstraint, constraintManager);
switcher.put(Pickup.class, serviceInsertionCalc);
switcher.put(Shipment.class, insertionCalculator);
Pickup service = (Pickup)Pickup.Builder.newInstance("pick", 1).setLocationId("5,5").build();
InsertionData iData = switcher.getInsertionData(route, service, vehicle, 0, DriverImpl.noDriver(), Double.MAX_VALUE);
// routeActVisitor.visit(route);
assertEquals(3, iData.getDeliveryInsertionIndex());
}
} }

2
jsprit-core/src/test/java/algorithms/StateUpdates.java
View file

@ -45,7 +45,7 @@ class UpdateStates implements JobInsertedListener, InsertionStartsListener{
routeActivityVisitor.addActivityVisitor(new UpdateActivityTimes(routingCosts)); routeActivityVisitor.addActivityVisitor(new UpdateActivityTimes(routingCosts));
routeActivityVisitor.addActivityVisitor(new UpdateVariableCosts(activityCosts, routingCosts, states)); routeActivityVisitor.addActivityVisitor(new UpdateVariableCosts(activityCosts, routingCosts, states));
routeActivityVisitor.addActivityVisitor(new UpdateLoads(states)); routeActivityVisitor.addActivityVisitor(new UpdateLoads(states));
routeActivityVisitor.addActivityVisitor(new UpdateMaxLoad(states)); routeActivityVisitor.addActivityVisitor(new UpdateMaxLoad_(states));
revRouteActivityVisitor = new ReverseRouteActivityVisitor(); revRouteActivityVisitor = new ReverseRouteActivityVisitor();
revRouteActivityVisitor.addActivityVisitor(new TimeWindowUpdater(states, routingCosts)); revRouteActivityVisitor.addActivityVisitor(new TimeWindowUpdater(states, routingCosts));
insertionListeners.addListener(new UpdateLoads(states)); insertionListeners.addListener(new UpdateLoads(states));

5
jsprit-core/src/test/java/basics/route/VehicleRouteBuilderTest.java
View file

@ -1,10 +1,11 @@
package basics.route; package basics.route;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import org.junit.Test; import org.junit.Test;
import basics.Shipment; import basics.Shipment;
import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;
public class VehicleRouteBuilderTest { public class VehicleRouteBuilderTest {

36442
jsprit-core/src/test/resources/pdp_sol.xml
View file

File diff suppressed because it is too large Load diff

5
jsprit-examples/src/main/java/examples/PickupAndDeliveryExample2.java
View file

@ -19,6 +19,9 @@ package examples;
import java.io.File; import java.io.File;
import java.util.Collection; import java.util.Collection;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import algorithms.VehicleRoutingAlgorithms; import algorithms.VehicleRoutingAlgorithms;
import algorithms.selectors.SelectBest; import algorithms.selectors.SelectBest;
import analysis.AlgorithmSearchProgressChartListener; import analysis.AlgorithmSearchProgressChartListener;
@ -37,6 +40,8 @@ public class PickupAndDeliveryExample2 {
public static void main(String[] args) { public static void main(String[] args) {
Logger.getRootLogger().setLevel(Level.INFO);
/* /*
* some preparation - create output folder * some preparation - create output folder
*/ */