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

relax api

Browse source
This commit is contained in:
Stefan Schroeder 2013-10-22 15:31:02 +02:00
parent ee94ac2e21
commit 1e520f3269
42 changed files with 382 additions and 948 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -32,29 +32,38 @@ public class BestInsertionBuilder implements InsertionStrategyBuilder{
this.stateManager = stateManager;
this.constraintManager = new ConstraintManager();
this.fleetManager = vehicleFleetManager;
addCoreStateUpdaters();
}
/**
* Adds core constraints, i.e.
*
* <p>HardPickupAndDeliveryLoadRouteLevelConstraint<br>
* HardTimeWindowActivityLevelConstraint<br>
* if(Constraint.DELIVERIES_FIRST) HardPickupAndDeliveryBackhaulActivityLevelConstraint<br>
* else HardPickupAndDeliveryActivityLevelConstraint
* @return
*/
public BestInsertionBuilder addCoreConstraints(){
private void addCoreStateUpdaters(){
stateManager.addListener(new UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts(stateManager));
stateManager.addListener(new UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted(stateManager));
stateManager.addActivityVisitor(new UpdateMaxLoad(stateManager));
stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
stateManager.addActivityVisitor(new UpdateCostsAtAllLevels(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
}
public BestInsertionBuilder addHardLoadConstraints(){
constraintManager.addConstraint(new HardPickupAndDeliveryLoadRouteLevelConstraint(stateManager));
constraintManager.addConstraint(new HardTimeWindowActivityLevelConstraint(stateManager, vrp.getTransportCosts()));
if(vrp.getProblemConstraints().contains(Constraint.DELIVERIES_FIRST)){
constraintManager.addConstraint(new HardPickupAndDeliveryBackhaulActivityLevelConstraint(stateManager));
}
else{
constraintManager.addConstraint(new HardPickupAndDeliveryActivityLevelConstraint(stateManager));
}
StateUtils.addCoreStateUpdaters(vrp, stateManager);
stateManager.addActivityVisitor(new UpdateOccuredDeliveriesAtActivityLevel(stateManager));
stateManager.addActivityVisitor(new UpdateFuturePickupsAtActivityLevel(stateManager));
return this;
}
public BestInsertionBuilder addHardTimeWindowConstraint(){
constraintManager.addConstraint(new HardTimeWindowActivityLevelConstraint(stateManager, vrp.getTransportCosts()));
stateManager.addActivityVisitor(new UpdateEarliestStartTimeWindowAtActLocations(stateManager, vrp.getTransportCosts()));
stateManager.addActivityVisitor(new UpdateLatestOperationStartTimeAtActLocations(stateManager, vrp.getTransportCosts()));
return this;
}
public BestInsertionBuilder addConstraint(HardActivityLevelConstraint hardActvitiyLevelConstraint){
constraintManager.addConstraint(hardActvitiyLevelConstraint);
@ -115,7 +124,7 @@ public class BestInsertionBuilder implements InsertionStrategyBuilder{
private void addCoreUpdater() {
if(!hasActivityTimeUpdater()){
stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
}
// if(!hasLoadUpdater()){
// stateManager.addActivityVisitor(new UpdateLoadAtActivityLevel(stateManager));

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

@ -236,7 +236,7 @@ class CalculatorBuilder {
}
private CalculatorPlusListeners createCalculatorConsideringFixedCosts(VehicleRoutingProblem vrp, JobInsertionCalculator baseCalculator, StateGetter activityStates2, double weightOfFixedCosts){
final CalculatesServiceInsertionConsideringFixCost withFixCost = new CalculatesServiceInsertionConsideringFixCost(baseCalculator, activityStates2);
final JobInsertionConsideringFixCostsCalculator withFixCost = new JobInsertionConsideringFixCostsCalculator(baseCalculator, activityStates2);
withFixCost.setWeightOfFixCost(weightOfFixedCosts);
CalculatorPlusListeners calcPlusListeners = new CalculatorPlusListeners(withFixCost);
calcPlusListeners.getInsertionListener().add(new ConfigureFixCostCalculator(vrp, withFixCost));
@ -262,7 +262,7 @@ class CalculatorBuilder {
}
private JobInsertionCalculator createFinalInsertion(VehicleFleetManager fleetManager, JobInsertionCalculator baseCalc, StateGetter activityStates2){
return new CalculatesVehTypeDepServiceInsertion(fleetManager, baseCalc);
return new VehicleTypeDependentJobInsertionCalculator(fleetManager, baseCalc);
}
public void setConstraintManager(ConstraintManager constraintManager) {

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

@ -37,11 +37,11 @@ final class ConfigureFixCostCalculator implements InsertionStartsListener, JobIn
VehicleRoutingProblem vrp;
CalculatesServiceInsertionConsideringFixCost calcConsideringFix;
JobInsertionConsideringFixCostsCalculator calcConsideringFix;
private int nuOfJobsToRecreate;
public ConfigureFixCostCalculator(VehicleRoutingProblem vrp, CalculatesServiceInsertionConsideringFixCost calcConsideringFix) {
public ConfigureFixCostCalculator(VehicleRoutingProblem vrp, JobInsertionConsideringFixCostsCalculator calcConsideringFix) {
super();
this.vrp = vrp;
this.calcConsideringFix = calcConsideringFix;

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

@ -79,11 +79,11 @@ final class FindCheaperVehicleAlgo {
if(vehicle.getType().getTypeId().equals(vehicleRoute.getVehicle().getType().getTypeId())){
continue;
}
if(states.getRouteState(vehicleRoute,StateIdFactory.LOAD).toDouble() <= vehicle.getCapacity()){
if(states.getRouteState(vehicleRoute,StateFactory.LOAD).toDouble() <= vehicle.getCapacity()){
double fixCostSaving = vehicleRoute.getVehicle().getType().getVehicleCostParams().fix - vehicle.getType().getVehicleCostParams().fix;
double departureTime = vehicleRoute.getStart().getEndTime();
double newCost = auxilliaryCostCalculator.costOfPath(path, departureTime, vehicleRoute.getDriver(), vehicle);
double varCostSaving = states.getRouteState(vehicleRoute, StateIdFactory.COSTS).toDouble() - newCost;
double varCostSaving = states.getRouteState(vehicleRoute, StateFactory.COSTS).toDouble() - newCost;
double totalCostSaving = varCostSaving + weightFixCosts*fixCostSaving;
if(totalCostSaving > bestSaving){
bestSaving = totalCostSaving;

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

@ -13,7 +13,7 @@ class HardLoadConstraint implements HardRouteLevelConstraint{
@Override
public boolean fulfilled(InsertionContext insertionContext) {
int currentLoad = (int) states.getRouteState(insertionContext.getRoute(), StateIdFactory.LOAD).toDouble();
int currentLoad = (int) states.getRouteState(insertionContext.getRoute(), StateFactory.LOAD).toDouble();
Service service = (Service) insertionContext.getJob();
if(currentLoad + service.getCapacityDemand() > insertionContext.getNewVehicle().getCapacity()){
return false;

10
jsprit-core/src/main/java/algorithms/HardPickupAndDeliveryActivityLevelConstraint.java
View file

@ -21,14 +21,14 @@ class HardPickupAndDeliveryActivityLevelConstraint implements HardActivityLevelC
int futurePicks;
int pastDeliveries;
if(prevAct instanceof Start){
loadAtPrevAct = (int)stateManager.getRouteState(iFacts.getRoute(), StateIdFactory.LOAD_AT_BEGINNING).toDouble();
futurePicks = (int)stateManager.getRouteState(iFacts.getRoute(), StateIdFactory.LOAD).toDouble();
loadAtPrevAct = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.LOAD_AT_BEGINNING).toDouble();
futurePicks = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.LOAD_AT_END).toDouble();
pastDeliveries = 0;
}
else{
loadAtPrevAct = (int) stateManager.getActivityState(prevAct, StateIdFactory.LOAD).toDouble();
futurePicks = (int) stateManager.getActivityState(prevAct, StateIdFactory.FUTURE_PICKS).toDouble();
pastDeliveries = (int) stateManager.getActivityState(prevAct, StateIdFactory.PAST_DELIVERIES).toDouble();
loadAtPrevAct = (int) stateManager.getActivityState(prevAct, StateFactory.LOAD).toDouble();
futurePicks = (int) stateManager.getActivityState(prevAct, StateFactory.FUTURE_PICKS).toDouble();
pastDeliveries = (int) stateManager.getActivityState(prevAct, StateFactory.PAST_DELIVERIES).toDouble();
}
if(newAct instanceof PickupActivity || newAct instanceof ServiceActivity){
if(loadAtPrevAct + newAct.getCapacityDemand() + futurePicks > iFacts.getNewVehicle().getCapacity()){

10
jsprit-core/src/main/java/algorithms/HardPickupAndDeliveryBackhaulActivityLevelConstraint.java
View file

@ -25,14 +25,14 @@ class HardPickupAndDeliveryBackhaulActivityLevelConstraint implements HardActivi
int futurePicks;
int pastDeliveries;
if(prevAct instanceof Start){
loadAtPrevAct = (int)stateManager.getRouteState(iFacts.getRoute(), StateIdFactory.LOAD_AT_BEGINNING).toDouble();
futurePicks = (int)stateManager.getRouteState(iFacts.getRoute(), StateIdFactory.LOAD).toDouble();
loadAtPrevAct = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.LOAD_AT_BEGINNING).toDouble();
futurePicks = (int)stateManager.getRouteState(iFacts.getRoute(), StateFactory.LOAD_AT_END).toDouble();
pastDeliveries = 0;
}
else{
loadAtPrevAct = (int) stateManager.getActivityState(prevAct, StateIdFactory.LOAD).toDouble();
futurePicks = (int) stateManager.getActivityState(prevAct, StateIdFactory.FUTURE_PICKS).toDouble();
pastDeliveries = (int) stateManager.getActivityState(prevAct, StateIdFactory.PAST_DELIVERIES).toDouble();
loadAtPrevAct = (int) stateManager.getActivityState(prevAct, StateFactory.LOAD).toDouble();
futurePicks = (int) stateManager.getActivityState(prevAct, StateFactory.FUTURE_PICKS).toDouble();
pastDeliveries = (int) stateManager.getActivityState(prevAct, StateFactory.PAST_DELIVERIES).toDouble();
}
if(newAct instanceof PickupActivity || newAct instanceof ServiceActivity){
if(loadAtPrevAct + newAct.getCapacityDemand() + futurePicks > iFacts.getNewVehicle().getCapacity()){

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

@ -22,13 +22,13 @@ class HardPickupAndDeliveryLoadRouteLevelConstraint implements HardRouteLevelCon
@Override
public boolean fulfilled(InsertionContext insertionContext) {
if(insertionContext.getJob() instanceof Delivery){
int loadAtDepot = (int) stateManager.getRouteState(insertionContext.getRoute(), StateIdFactory.LOAD_AT_BEGINNING).toDouble();
int loadAtDepot = (int) stateManager.getRouteState(insertionContext.getRoute(), StateFactory.LOAD_AT_BEGINNING).toDouble();
if(loadAtDepot + insertionContext.getJob().getCapacityDemand() > insertionContext.getNewVehicle().getCapacity()){
return false;
}
}
else if(insertionContext.getJob() instanceof Pickup || insertionContext.getJob() instanceof Service){
int loadAtEnd = (int) stateManager.getRouteState(insertionContext.getRoute(), StateIdFactory.LOAD).toDouble();
int loadAtEnd = (int) stateManager.getRouteState(insertionContext.getRoute(), StateFactory.LOAD_AT_END).toDouble();
if(loadAtEnd + insertionContext.getJob().getCapacityDemand() > insertionContext.getNewVehicle().getCapacity()){
return false;
}

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

@ -28,14 +28,14 @@ import basics.route.TourActivity;
public boolean fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
// log.info("check insertion of " + newAct + " between " + prevAct + " and " + nextAct + ". prevActDepTime=" + prevActDepTime);
double arrTimeAtNewAct = prevActDepTime + routingCosts.getTransportTime(prevAct.getLocationId(), newAct.getLocationId(), prevActDepTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
double latestArrTimeAtNewAct = states.getActivityState(newAct, StateIdFactory.LATEST_OPERATION_START_TIME).toDouble();
double latestArrTimeAtNewAct = states.getActivityState(newAct, StateFactory.LATEST_OPERATION_START_TIME).toDouble();
if(arrTimeAtNewAct > latestArrTimeAtNewAct){
return false;
}
// log.info(newAct + " arrTime=" + arrTimeAtNewAct);
double endTimeAtNewAct = CalculationUtils.getActivityEndTime(arrTimeAtNewAct, newAct);
double arrTimeAtNextAct = endTimeAtNewAct + routingCosts.getTransportTime(newAct.getLocationId(), nextAct.getLocationId(), endTimeAtNewAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
double latestArrTimeAtNextAct = states.getActivityState(nextAct, StateIdFactory.LATEST_OPERATION_START_TIME).toDouble();
double latestArrTimeAtNextAct = states.getActivityState(nextAct, StateFactory.LATEST_OPERATION_START_TIME).toDouble();
if(arrTimeAtNextAct > latestArrTimeAtNextAct){
return false;
}

18
jsprit-core/src/main/java/algorithms/CalculatesServiceInsertionConsideringFixCost.java → jsprit-core/src/main/java/algorithms/JobInsertionConsideringFixCostsCalculator.java
View file

@ -27,9 +27,9 @@ import basics.route.VehicleRoute;
final class CalculatesServiceInsertionConsideringFixCost implements JobInsertionCalculator{
final class JobInsertionConsideringFixCostsCalculator implements JobInsertionCalculator{
private static final Logger logger = Logger.getLogger(CalculatesServiceInsertionConsideringFixCost.class);
private static final Logger logger = Logger.getLogger(JobInsertionConsideringFixCostsCalculator.class);
private final JobInsertionCalculator standardServiceInsertion;
@ -37,12 +37,12 @@ final class CalculatesServiceInsertionConsideringFixCost implements JobInsertion
private double solution_completeness_ratio = 0.5;
private StateGetter states;
private StateGetter stateGetter;
public CalculatesServiceInsertionConsideringFixCost(final JobInsertionCalculator standardInsertionCalculator, StateGetter activityStates2) {
public JobInsertionConsideringFixCostsCalculator(final JobInsertionCalculator standardInsertionCalculator, StateGetter stateGetter) {
super();
this.standardServiceInsertion = standardInsertionCalculator;
this.states = activityStates2;
this.stateGetter = stateGetter;
logger.info("inialise " + this);
}
@ -80,7 +80,7 @@ final class CalculatesServiceInsertionConsideringFixCost implements JobInsertion
}
private double getDeltaAbsoluteFixCost(VehicleRoute route, Vehicle newVehicle, Job job) {
double load = getCurrentLoad(route) + job.getCapacityDemand();
double load = getCurrentMaxLoadInRoute(route) + job.getCapacityDemand();
double currentFix = 0.0;
if(route.getVehicle() != null){
if(!(route.getVehicle() instanceof NoVehicle)){
@ -94,7 +94,7 @@ final class CalculatesServiceInsertionConsideringFixCost implements JobInsertion
}
private double getDeltaRelativeFixCost(VehicleRoute route, Vehicle newVehicle, Job job) {
int currentLoad = getCurrentLoad(route);
int currentLoad = getCurrentMaxLoadInRoute(route);
double load = currentLoad + job.getCapacityDemand();
double currentRelFix = 0.0;
if(route.getVehicle() != null){
@ -109,8 +109,8 @@ final class CalculatesServiceInsertionConsideringFixCost implements JobInsertion
return relativeFixCost;
}
private int getCurrentLoad(VehicleRoute route) {
return (int) states.getRouteState(route, StateIdFactory.LOAD).toDouble();
private int getCurrentMaxLoadInRoute(VehicleRoute route) {
return (int) stateGetter.getRouteState(route, StateFactory.MAXLOAD).toDouble();
}
}

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

@ -69,9 +69,9 @@ class RouteLevelActivityInsertionCostsEstimator implements ActivityInsertionCost
private double actCostsOld(VehicleRoute vehicleRoute, TourActivity act) {
if(act instanceof End){
return stateManager.getRouteState(vehicleRoute,StateIdFactory.COSTS).toDouble();
return stateManager.getRouteState(vehicleRoute,StateFactory.COSTS).toDouble();
}
return stateManager.getActivityState(act,StateIdFactory.COSTS).toDouble();
return stateManager.getActivityState(act,StateFactory.COSTS).toDouble();
}
private List<TourActivity> getForwardLookingPath(VehicleRoute route, int actIndex) {

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

@ -276,7 +276,7 @@ final class ServiceInsertionOnRouteLevelCalculator implements JobInsertionCalcul
/**
* compute cost-diff of tour with and without new activity --> insertion_costs
*/
double insertion_costs = auxilliaryPathCostCalculator.costOfPath(wholeTour, start.getEndTime(), newDriver, newVehicle) - stateManager.getRouteState(currentRoute,StateIdFactory.COSTS).toDouble();
double insertion_costs = auxilliaryPathCostCalculator.costOfPath(wholeTour, start.getEndTime(), newDriver, newVehicle) - stateManager.getRouteState(currentRoute,StateFactory.COSTS).toDouble();
/**
* if better than best known, make it the best known
@ -321,9 +321,9 @@ final class ServiceInsertionOnRouteLevelCalculator implements JobInsertionCalcul
private double sumOf_prevCosts_oldVehicle(VehicleRoute vehicleRoute, TourActivity act) {
if(act instanceof End){
return stateManager.getRouteState(vehicleRoute,StateIdFactory.COSTS).toDouble();
return stateManager.getRouteState(vehicleRoute,StateFactory.COSTS).toDouble();
}
return stateManager.getActivityState(act,StateIdFactory.COSTS).toDouble();
return stateManager.getActivityState(act,StateFactory.COSTS).toDouble();
}
/**

31
jsprit-core/src/main/java/algorithms/SolutionCostCalculatorFactory.java Normal file
View file

@ -0,0 +1,31 @@
package algorithms;
import basics.VehicleRoutingProblemSolution;
import basics.algo.SolutionCostCalculator;
import basics.route.VehicleRoute;
public class SolutionCostCalculatorFactory {
private StateManager stateManager;
public SolutionCostCalculatorFactory(StateManager stateManager) {
super();
this.stateManager = stateManager;
}
public SolutionCostCalculator createCalculator(){
return new SolutionCostCalculator() {
@Override
public void calculateCosts(VehicleRoutingProblemSolution solution) {
double c = 0.0;
for(VehicleRoute r : solution.getRoutes()){
c += stateManager.getRouteState(r, StateFactory.COSTS).toDouble();
c += r.getVehicle().getType().getVehicleCostParams().fix;
}
solution.setCost(c);
}
};
}
}

12
jsprit-core/src/main/java/algorithms/StateIdFactory.java → jsprit-core/src/main/java/algorithms/StateFactory.java
View file

@ -23,9 +23,13 @@ package algorithms;
import java.util.Arrays;
import java.util.List;
import algorithms.StateGetter.State;
import algorithms.StateGetter.StateId;
import algorithms.StateManager.StateImpl;
public class StateIdFactory {
public class StateFactory {
final static StateId MAXLOAD = new StateIdImpl("maxload");
final static StateId LOAD = new StateIdImpl("load");
@ -45,7 +49,7 @@ public class StateIdFactory {
final static StateId PAST_DELIVERIES = new StateIdImpl("pastDeliveries");
final static List<String> reservedIds = Arrays.asList("load","costs","loadAtBeginning","loadAtEnd","duration","latestOST","earliestOST"
final static List<String> reservedIds = Arrays.asList("maxload","load","costs","loadAtBeginning","loadAtEnd","duration","latestOST","earliestOST"
,"futurePicks","pastDeliveries");
@ -53,6 +57,10 @@ public class StateIdFactory {
if(reservedIds.contains(name)){ throwException(name); }
return new StateIdImpl(name);
}
public static State createState(double value){
return new StateImpl(value);
}
private static void throwException(String name) {
throw new IllegalStateException("state-id with name '" + name + "' cannot be created. it is already reserved internally.");

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

@ -46,7 +46,7 @@ public class StateManager implements StateGetter, IterationStartsListener, RuinL
}
public static class StateImpl implements State{
static class StateImpl implements State{
double state;
public StateImpl(double state) {
@ -92,6 +92,18 @@ public class StateManager implements StateGetter, IterationStartsListener, RuinL
private Collection<StateUpdater> updaters = new ArrayList<StateUpdater>();
private Map<StateId,State> defaultRouteStates = new HashMap<StateGetter.StateId, StateGetter.State>();
private Map<StateId,State> defaultActivityStates = new HashMap<StateId, State>();
public void addDefaultRouteState(StateId stateId, State defaultState){
defaultRouteStates.put(stateId, defaultState);
}
public void addDefaultActivityState(StateId stateId, State defaultState){
defaultActivityStates.put(stateId, defaultState);
}
public void clear(){
vehicleRouteStates.clear();
activityStates.clear();
@ -208,21 +220,23 @@ public class StateManager implements StateGetter, IterationStartsListener, RuinL
}
private State getDefaultActState(StateId stateId, TourActivity act){
if(stateId.equals(StateIdFactory.LOAD)) return new StateImpl(0);
if(stateId.equals(StateIdFactory.COSTS)) return new StateImpl(0);
if(stateId.equals(StateIdFactory.DURATION)) return new StateImpl(0);
if(stateId.equals(StateIdFactory.EARLIEST_OPERATION_START_TIME)) return new StateImpl(act.getTheoreticalEarliestOperationStartTime());
if(stateId.equals(StateIdFactory.LATEST_OPERATION_START_TIME)) return new StateImpl(act.getTheoreticalLatestOperationStartTime());
if(stateId.equals(StateIdFactory.FUTURE_PICKS)) return new StateImpl(0);
if(stateId.equals(StateIdFactory.PAST_DELIVERIES)) return new StateImpl(0);
if(stateId.equals(StateFactory.LOAD)) return new StateImpl(0);
if(stateId.equals(StateFactory.COSTS)) return new StateImpl(0);
if(stateId.equals(StateFactory.DURATION)) return new StateImpl(0);
if(stateId.equals(StateFactory.EARLIEST_OPERATION_START_TIME)) return new StateImpl(act.getTheoreticalEarliestOperationStartTime());
if(stateId.equals(StateFactory.LATEST_OPERATION_START_TIME)) return new StateImpl(act.getTheoreticalLatestOperationStartTime());
if(stateId.equals(StateFactory.FUTURE_PICKS)) return new StateImpl(0);
if(stateId.equals(StateFactory.PAST_DELIVERIES)) return new StateImpl(0);
return null;
}
private State getDefaultRouteState(StateId stateId, VehicleRoute route){
if(stateId.equals(StateIdFactory.LOAD)) return new StateImpl(0);
if(stateId.equals(StateIdFactory.LOAD_AT_BEGINNING)) return new StateImpl(0);
if(stateId.equals(StateIdFactory.COSTS)) return new StateImpl(0);
if(stateId.equals(StateIdFactory.DURATION)) return new StateImpl(0);
if(stateId.equals(StateFactory.MAXLOAD)) return new StateImpl(0);
if(stateId.equals(StateFactory.LOAD)) return new StateImpl(0);
if(stateId.equals(StateFactory.LOAD_AT_END)) return new StateImpl(0);
if(stateId.equals(StateFactory.LOAD_AT_BEGINNING)) return new StateImpl(0);
if(stateId.equals(StateFactory.COSTS)) return new StateImpl(0);
if(stateId.equals(StateFactory.DURATION)) return new StateImpl(0);
return null;
}

811
jsprit-core/src/main/java/algorithms/StateUpdates.java
View file

@ -1,811 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package algorithms;
import java.util.Collection;
import basics.Job;
import basics.algo.JobInsertedListener;
import basics.algo.RuinListener;
import basics.costs.VehicleRoutingActivityCosts;
import basics.costs.VehicleRoutingTransportCosts;
import basics.route.VehicleRoute;
class StateUpdates {
// static class UpdateCostsAtRouteLevel implements JobInsertedListener, InsertionStartsListener, InsertionEndsListener{
//
// private StateManagerImpl states;
//
// private VehicleRoutingTransportCosts tpCosts;
//
// private VehicleRoutingActivityCosts actCosts;
//
// public UpdateCostsAtRouteLevel(StateManagerImpl states, VehicleRoutingTransportCosts tpCosts, VehicleRoutingActivityCosts actCosts) {
// super();
// this.states = states;
// this.tpCosts = tpCosts;
// this.actCosts = actCosts;
// }
//
// @Override
// public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
//// inRoute.getVehicleRouteCostCalculator().addTransportCost(additionalCosts);
// double oldCosts = states.getRouteState(inRoute, StateTypes.COSTS).toDouble();
// oldCosts += additionalCosts;
// states.putRouteState(inRoute, StateTypes.COSTS, new StateImpl(oldCosts));
// }
//
// @Override
// public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
// RouteActivityVisitor forwardInTime = new RouteActivityVisitor();
// forwardInTime.addActivityVisitor(new UpdateCostsAtAllLevels(actCosts, tpCosts, states));
// for(VehicleRoute route : vehicleRoutes){
// forwardInTime.visit(route);
// }
//
// }
//
// @Override
// public void informInsertionEnds(Collection<VehicleRoute> vehicleRoutes) {
//
//// IterateRouteForwardInTime forwardInTime = new IterateRouteForwardInTime(tpCosts);
//// forwardInTime.addListener(new UpdateCostsAtAllLevels(actCosts, tpCosts, states));
//// for(VehicleRoute route : vehicleRoutes){
//// if(route.isEmpty()) continue;
//// route.getVehicleRouteCostCalculator().reset();
//// route.getVehicleRouteCostCalculator().addOtherCost(states.getRouteState(route, StateTypes.COSTS).toDouble());
//// route.getVehicleRouteCostCalculator().price(route.getVehicle());
//// forwardInTime.iterate(route);
//// }
//
// }
//
// }
//
// static class UpdateActivityTimes implements ActivityVisitor{
//
// private Logger log = Logger.getLogger(UpdateActivityTimes.class);
//
// private ActivityTimeTracker timeTracker;
//
// private VehicleRoute route;
//
// public UpdateActivityTimes(ForwardTransportTime transportTime) {
// super();
// timeTracker = new ActivityTimeTracker(transportTime);
// }
//
// @Override
// public void begin(VehicleRoute route) {
// timeTracker.begin(route);
// this.route = route;
// route.getStart().setEndTime(timeTracker.getActEndTime());
// }
//
// @Override
// public void visit(TourActivity activity) {
// timeTracker.visit(activity);
// activity.setArrTime(timeTracker.getActArrTime());
// activity.setEndTime(timeTracker.getActEndTime());
// }
//
// @Override
// public void finish() {
// timeTracker.finish();
// route.getEnd().setArrTime(timeTracker.getActArrTime());
// }
//
// }
//
// static class UpdateCostsAtAllLevels implements ActivityVisitor{
//
// private static Logger log = Logger.getLogger(UpdateCostsAtAllLevels.class);
//
// private VehicleRoutingActivityCosts activityCost;
//
// private ForwardTransportCost transportCost;
//
// private StateManagerImpl states;
//
// private double totalOperationCost = 0.0;
//
// private VehicleRoute vehicleRoute = null;
//
// private TourActivity prevAct = null;
//
// private double startTimeAtPrevAct = 0.0;
//
// private ActivityTimeTracker timeTracker;
//
// public UpdateCostsAtAllLevels(VehicleRoutingActivityCosts activityCost, VehicleRoutingTransportCosts transportCost, StateManagerImpl states) {
// super();
// this.activityCost = activityCost;
// this.transportCost = transportCost;
// this.states = states;
// timeTracker = new ActivityTimeTracker(transportCost);
// }
//
// @Override
// public void begin(VehicleRoute route) {
// vehicleRoute = route;
// vehicleRoute.getVehicleRouteCostCalculator().reset();
// timeTracker.begin(route);
// prevAct = route.getStart();
// startTimeAtPrevAct = timeTracker.getActEndTime();
// }
//
// @Override
// public void visit(TourActivity act) {
// timeTracker.visit(act);
//
// double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), act.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
// double actCost = activityCost.getActivityCost(act, timeTracker.getActArrTime(), vehicleRoute.getDriver(), vehicleRoute.getVehicle());
//
//// vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost);
//// vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost);
//
// totalOperationCost += transportCost;
// totalOperationCost += actCost;
//
// states.putActivityState(act, StateTypes.COSTS, new StateImpl(totalOperationCost));
//
// prevAct = act;
// startTimeAtPrevAct = timeTracker.getActEndTime();
// }
//
// @Override
// public void finish() {
// timeTracker.finish();
// double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), vehicleRoute.getEnd().getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
// double actCost = activityCost.getActivityCost(vehicleRoute.getEnd(), timeTracker.getActEndTime(), vehicleRoute.getDriver(), vehicleRoute.getVehicle());
//
//// vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost);
//// vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost);
//
// totalOperationCost += transportCost;
// totalOperationCost += actCost;
// totalOperationCost += getFixCosts();
//
// states.putRouteState(vehicleRoute, StateTypes.COSTS, new StateImpl(totalOperationCost));
//
// //this is rather strange and likely to change
//// vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getDriver());
//// vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getVehicle());
//// vehicleRoute.getVehicleRouteCostCalculator().finish();
//
// startTimeAtPrevAct = 0.0;
// prevAct = null;
// vehicleRoute = null;
// totalOperationCost = 0.0;
// }
//
// private double getFixCosts() {
// Vehicle vehicle = vehicleRoute.getVehicle();
// if(vehicle == null) return 0.0;
// VehicleType type = vehicle.getType();
// if(type == null) return 0.0;
// return type.getVehicleCostParams().fix;
// }
//
// }
//
// static class UpdateEarliestStartTimeWindowAtActLocations implements ActivityVisitor{
//
// private StateManagerImpl states;
//
// private ActivityTimeTracker timeTracker;
//
// public UpdateEarliestStartTimeWindowAtActLocations(StateManagerImpl states, VehicleRoutingTransportCosts transportCosts) {
// super();
// this.states = states;
// timeTracker = new ActivityTimeTracker(transportCosts);
// }
//
// @Override
// public void begin(VehicleRoute route) {
// timeTracker.begin(route);
// }
//
// @Override
// public void visit(TourActivity activity) {
// timeTracker.visit(activity);
// states.putActivityState(activity, StateTypes.EARLIEST_OPERATION_START_TIME, new StateImpl(Math.max(timeTracker.getActArrTime(), activity.getTheoreticalEarliestOperationStartTime())));
//
// }
//
// @Override
// public void finish() {}
//
// }
//
// static class UpdateLatestOperationStartTimeAtActLocations implements ReverseActivityVisitor{
//
// private static Logger log = Logger.getLogger(UpdateLatestOperationStartTimeAtActLocations.class);
//
// private StateManagerImpl states;
//
// private VehicleRoute route;
//
// private VehicleRoutingTransportCosts transportCosts;
//
// private double latestArrTimeAtPrevAct;
//
// private TourActivity prevAct;
//
// public UpdateLatestOperationStartTimeAtActLocations(StateManagerImpl states, VehicleRoutingTransportCosts tpCosts) {
// super();
// this.states = states;
// this.transportCosts = tpCosts;
// }
//
// @Override
// public void begin(VehicleRoute route) {
// this.route = route;
// latestArrTimeAtPrevAct = route.getEnd().getTheoreticalLatestOperationStartTime();
// prevAct = route.getEnd();
// }
//
// @Override
// public void visit(TourActivity activity) {
// double potentialLatestArrivalTimeAtCurrAct = latestArrTimeAtPrevAct - transportCosts.getBackwardTransportTime(activity.getLocationId(), prevAct.getLocationId(), latestArrTimeAtPrevAct, route.getDriver(),route.getVehicle()) - activity.getOperationTime();
// double latestArrivalTime = Math.min(activity.getTheoreticalLatestOperationStartTime(), potentialLatestArrivalTimeAtCurrAct);
//
// states.putActivityState(activity, StateTypes.LATEST_OPERATION_START_TIME, new StateImpl(latestArrivalTime));
//
// latestArrTimeAtPrevAct = latestArrivalTime;
// prevAct = activity;
// }
//
// @Override
// public void finish() {}
// }
//
// static class UpdateLoadAtAllLevels implements ActivityVisitor{
//
// private double load = 0.0;
//
// private StateManagerImpl states;
//
// private VehicleRoute vehicleRoute;
//
// public UpdateLoadAtAllLevels(StateManagerImpl states) {
// super();
// this.states = states;
// }
//
// @Override
// public void begin(VehicleRoute route) {
// vehicleRoute = route;
// }
//
// @Override
// public void visit(TourActivity activity) {
// load += (double)activity.getCapacityDemand();
// states.putActivityState(activity, StateTypes.LOAD, new StateImpl(load));
// }
//
// @Override
// public void finish() {
// states.putRouteState(vehicleRoute, StateTypes.LOAD, new StateImpl(load));
// load=0;
// vehicleRoute = null;
// }
//
// }
//
// static class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsListener{
//
// private StateManagerImpl states;
//
// public UpdateLoadAtRouteLevel(StateManagerImpl states) {
// super();
// this.states = states;
// }
//
// @Override
// public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
// if(!(job2insert instanceof Service)){
// return;
// }
// double oldLoad = states.getRouteState(inRoute, StateTypes.LOAD).toDouble();
// states.putRouteState(inRoute, StateTypes.LOAD, new StateImpl(oldLoad + job2insert.getCapacityDemand()));
// }
//
// @Override
// public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
// for(VehicleRoute route : vehicleRoutes){
// int load = 0;
// for(Job j : route.getTourActivities().getJobs()){
// load += j.getCapacityDemand();
// }
// states.putRouteState(route, StateTypes.LOAD, new StateImpl(load));
// }
//
// }
//
// }
//
//=======
//
// }
//
// }
//
// static class UpdateActivityTimes implements ActivityVisitor{
//
// private Logger log = Logger.getLogger(UpdateActivityTimes.class);
//
// private ActivityTimeTracker timeTracker;
//
// private VehicleRoute route;
//
// public UpdateActivityTimes(ForwardTransportTime transportTime) {
// super();
// timeTracker = new ActivityTimeTracker(transportTime);
// }
//
// @Override
// public void begin(VehicleRoute route) {
// timeTracker.begin(route);
// this.route = route;
// route.getStart().setEndTime(timeTracker.getActEndTime());
// }
//
// @Override
// public void visit(TourActivity activity) {
// timeTracker.visit(activity);
// activity.setArrTime(timeTracker.getActArrTime());
// activity.setEndTime(timeTracker.getActEndTime());
// }
//
// @Override
// public void finish() {
// timeTracker.finish();
// route.getEnd().setArrTime(timeTracker.getActArrTime());
// }
//
// }
//
// static class UpdateCostsAtAllLevels implements ActivityVisitor{
//
// private static Logger log = Logger.getLogger(UpdateCostsAtAllLevels.class);
//
// private VehicleRoutingActivityCosts activityCost;
//
// private ForwardTransportCost transportCost;
//
// private StateManagerImpl states;
//
// private double totalOperationCost = 0.0;
//
// private VehicleRoute vehicleRoute = null;
//
// private TourActivity prevAct = null;
//
// private double startTimeAtPrevAct = 0.0;
//
// private ActivityTimeTracker timeTracker;
//
// public UpdateCostsAtAllLevels(VehicleRoutingActivityCosts activityCost, VehicleRoutingTransportCosts transportCost, StateManagerImpl states) {
// super();
// this.activityCost = activityCost;
// this.transportCost = transportCost;
// this.states = states;
// timeTracker = new ActivityTimeTracker(transportCost);
// }
//
// @Override
// public void begin(VehicleRoute route) {
// vehicleRoute = route;
// vehicleRoute.getVehicleRouteCostCalculator().reset();
// timeTracker.begin(route);
// prevAct = route.getStart();
// startTimeAtPrevAct = timeTracker.getActEndTime();
// }
//
// @Override
// public void visit(TourActivity act) {
// timeTracker.visit(act);
//
// double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), act.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
// double actCost = activityCost.getActivityCost(act, timeTracker.getActArrTime(), vehicleRoute.getDriver(), vehicleRoute.getVehicle());
//
// vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost);
// vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost);
//
// totalOperationCost += transportCost;
// totalOperationCost += actCost;
//
// states.putActivityState(act, StateTypes.COSTS, new StateImpl(totalOperationCost));
//
// prevAct = act;
// startTimeAtPrevAct = timeTracker.getActEndTime();
// }
//
// @Override
// public void finish() {
// timeTracker.finish();
// double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), vehicleRoute.getEnd().getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
// double actCost = activityCost.getActivityCost(vehicleRoute.getEnd(), timeTracker.getActEndTime(), vehicleRoute.getDriver(), vehicleRoute.getVehicle());
//
// vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost);
// vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost);
//
// totalOperationCost += transportCost;
// totalOperationCost += actCost;
//// totalOperationCost += getFixCosts();
//
// states.putRouteState(vehicleRoute, StateTypes.COSTS, new StateImpl(totalOperationCost));
//
//// this is rather strange and likely to change
// vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getDriver());
// vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getVehicle());
// vehicleRoute.getVehicleRouteCostCalculator().finish();
//
// startTimeAtPrevAct = 0.0;
// prevAct = null;
// vehicleRoute = null;
// totalOperationCost = 0.0;
// }
//
// private double getFixCosts() {
// Vehicle vehicle = vehicleRoute.getVehicle();
// if(vehicle == null) return 0.0;
// VehicleType type = vehicle.getType();
// if(type == null) return 0.0;
// return type.getVehicleCostParams().fix;
// }
//
// }
//
// static class UpdateEarliestStartTimeWindowAtActLocations implements ActivityVisitor{
//
// private StateManagerImpl states;
//
// private ActivityTimeTracker timeTracker;
//
// public UpdateEarliestStartTimeWindowAtActLocations(StateManagerImpl states, VehicleRoutingTransportCosts transportCosts) {
// super();
// this.states = states;
// timeTracker = new ActivityTimeTracker(transportCosts);
// }
//
// @Override
// public void begin(VehicleRoute route) {
// timeTracker.begin(route);
// }
//
// @Override
// public void visit(TourActivity activity) {
// timeTracker.visit(activity);
// states.putActivityState(activity, StateTypes.EARLIEST_OPERATION_START_TIME, new StateImpl(Math.max(timeTracker.getActArrTime(), activity.getTheoreticalEarliestOperationStartTime())));
//
// }
//
// @Override
// public void finish() {}
//
// }
//
// static class UpdateLatestOperationStartTimeAtActLocations implements ReverseActivityVisitor{
//
// private static Logger log = Logger.getLogger(UpdateLatestOperationStartTimeAtActLocations.class);
//
// private StateManagerImpl states;
//
// private VehicleRoute route;
//
// private VehicleRoutingTransportCosts transportCosts;
//
// private double latestArrTimeAtPrevAct;
//
// private TourActivity prevAct;
//
// public UpdateLatestOperationStartTimeAtActLocations(StateManagerImpl states, VehicleRoutingTransportCosts tpCosts) {
// super();
// this.states = states;
// this.transportCosts = tpCosts;
// }
//
// @Override
// public void begin(VehicleRoute route) {
// this.route = route;
// latestArrTimeAtPrevAct = route.getEnd().getTheoreticalLatestOperationStartTime();
// prevAct = route.getEnd();
// }
//
// @Override
// public void visit(TourActivity activity) {
// double potentialLatestArrivalTimeAtCurrAct = latestArrTimeAtPrevAct - transportCosts.getBackwardTransportTime(activity.getLocationId(), prevAct.getLocationId(), latestArrTimeAtPrevAct, route.getDriver(),route.getVehicle()) - activity.getOperationTime();
// double latestArrivalTime = Math.min(activity.getTheoreticalLatestOperationStartTime(), potentialLatestArrivalTimeAtCurrAct);
//
// states.putActivityState(activity, StateTypes.LATEST_OPERATION_START_TIME, new StateImpl(latestArrivalTime));
//
// latestArrTimeAtPrevAct = latestArrivalTime;
// prevAct = activity;
// }
//
// @Override
// public void finish() {}
// }
//
// static class UpdateLoadAtAllLevels implements ActivityVisitor{
//
// private double load = 0.0;
//
// private StateManagerImpl states;
//
// private VehicleRoute vehicleRoute;
//
// public UpdateLoadAtAllLevels(StateManagerImpl states) {
// super();
// this.states = states;
// }
//
// @Override
// public void begin(VehicleRoute route) {
// vehicleRoute = route;
// }
//
// @Override
// public void visit(TourActivity activity) {
// load += (double)activity.getCapacityDemand();
// states.putActivityState(activity, StateTypes.LOAD, new StateImpl(load));
// }
//
// @Override
// public void finish() {
// states.putRouteState(vehicleRoute, StateTypes.LOAD, new StateImpl(load));
// load=0;
// vehicleRoute = null;
// }
//
// }
//
// static class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsListener{
//
// private StateManagerImpl states;
//
// public UpdateLoadAtRouteLevel(StateManagerImpl states) {
// super();
// this.states = states;
// }
//
// @Override
// public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
// if(!(job2insert instanceof Service)){
// return;
// }
// double oldLoad = states.getRouteState(inRoute, StateTypes.LOAD).toDouble();
// states.putRouteState(inRoute, StateTypes.LOAD, new StateImpl(oldLoad + job2insert.getCapacityDemand()));
// }
//
// @Override
// public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
// for(VehicleRoute route : vehicleRoutes){
// int load = 0;
// for(Job j : route.getTourActivities().getJobs()){
// load += j.getCapacityDemand();
// }
// states.putRouteState(route, StateTypes.LOAD, new StateImpl(load));
// }
//
// }
//
// }
//
//>>>>>>> refs/heads/master
static class UpdateStates implements JobInsertedListener, RuinListener{
private RouteActivityVisitor routeActivityVisitor;
private ReverseRouteActivityVisitor revRouteActivityVisitor;
public UpdateStates(StateManager states, VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts activityCosts) {
routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(new UpdateActivityTimes(routingCosts));
routeActivityVisitor.addActivityVisitor(new UpdateCostsAtAllLevels(activityCosts, routingCosts, states));
routeActivityVisitor.addActivityVisitor(new UpdateLoadAtAllLevels(states));
revRouteActivityVisitor = new ReverseRouteActivityVisitor();
revRouteActivityVisitor.addActivityVisitor(new UpdateLatestOperationStartTimeAtActLocations(states, routingCosts));
}
public void update(VehicleRoute route){
routeActivityVisitor.visit(route);
revRouteActivityVisitor.visit(route);
}
@Override
public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
routeActivityVisitor.visit(inRoute);
revRouteActivityVisitor.visit(inRoute);
}
@Override
public void ruinStarts(Collection<VehicleRoute> routes) {}
@Override
public void ruinEnds(Collection<VehicleRoute> routes,Collection<Job> unassignedJobs) {
for(VehicleRoute route : routes) {
routeActivityVisitor.visit(route);
revRouteActivityVisitor.visit(route);
}
}
@Override
public void removed(Job job, VehicleRoute fromRoute) {}
}
//
// static class UpdateFuturePickupsAtActivityLevel implements ReverseActivityVisitor {
// private StateManagerImpl stateManager;
// private int futurePicks = 0;
// private VehicleRoute route;
//
// public UpdateFuturePickupsAtActivityLevel(StateManagerImpl stateManager) {
// super();
// this.stateManager = stateManager;
// }
//
// @Override
// public void begin(VehicleRoute route) {
// this.route = route;
// }
//
// @Override
// public void visit(TourActivity act) {
// stateManager.putActivityState(act, StateTypes.FUTURE_PICKS, new StateImpl(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;
// }
// }
//
// static class UpdateOccuredDeliveriesAtActivityLevel implements ActivityVisitor {
// private StateManagerImpl stateManager;
// private int deliveries = 0;
// private VehicleRoute route;
//
// public UpdateOccuredDeliveriesAtActivityLevel(StateManagerImpl 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, StateTypes.PAST_DELIVERIES, new StateImpl(deliveries));
// assert deliveries >= 0 : "deliveries < 0";
// assert deliveries <= route.getVehicle().getCapacity() : "deliveries > vehicleCap";
// }
//
// @Override
// public void finish() {
// deliveries = 0;
// route = null;
// }
// }
//
// /**
// * Updates load at activity level. Note that this assumed that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT.
// * If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot.
// *
// * @author stefan
// *
// */
// static class UpdateLoadAtActivityLevel implements ActivityVisitor {
// private StateManagerImpl stateManager;
// private int currentLoad = 0;
// private VehicleRoute route;
//
// public UpdateLoadAtActivityLevel(StateManagerImpl stateManager) {
// super();
// this.stateManager = stateManager;
// }
//
// @Override
// public void begin(VehicleRoute route) {
// currentLoad = (int) stateManager.getRouteState(route, StateTypes.LOAD_AT_DEPOT).toDouble();
// this.route = route;
// }
//
// @Override
// public void visit(TourActivity act) {
// currentLoad += act.getCapacityDemand();
// stateManager.putActivityState(act, StateTypes.LOAD, new StateImpl(currentLoad));
// assert currentLoad <= route.getVehicle().getCapacity() : "currentLoad at activity must not be > vehicleCapacity";
// assert currentLoad >= 0 : "currentLoad at act must not be < 0";
// }
//
// @Override
// public void finish() {
// currentLoad = 0;
// }
// }
//
// static class ResetStateManager implements IterationStartsListener {
//
// private StateManagerImpl stateManager;
//
// public ResetStateManager(StateManagerImpl stateManager) {
// super();
// this.stateManager = stateManager;
// }
//
// @Override
// public void informIterationStarts(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
// stateManager.clear();
// }
// }
//
// static interface InsertionStarts {
//
// void insertionStarts(VehicleRoute route);
//
// }
//
// static class UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts implements InsertionStarts {
//
// private StateManagerImpl stateManager;
//
// public UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts(StateManagerImpl stateManager) {
// super();
// this.stateManager = stateManager;
// }
//
// @Override
// public void insertionStarts(VehicleRoute route) {
// int loadAtDepot = 0;
// int loadAtEnd = 0;
// for(Job j : route.getTourActivities().getJobs()){
// if(j instanceof Delivery){
// loadAtDepot += j.getCapacityDemand();
// }
// else if(j instanceof Pickup || j instanceof Service){
// loadAtEnd += j.getCapacityDemand();
// }
// }
// stateManager.putRouteState(route, StateTypes.LOAD_AT_DEPOT, new StateImpl(loadAtDepot));
// stateManager.putRouteState(route, StateTypes.LOAD, new StateImpl(loadAtEnd));
// }
//
// }
//
}

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

@ -2,10 +2,10 @@ package algorithms;
import basics.VehicleRoutingProblem;
public class StateUtils {
class StateUtils {
public static void addCoreStateUpdaters(VehicleRoutingProblem vrp, StateManager stateManager){
stateManager.addListener(new InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts(stateManager));
stateManager.addListener(new UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts(stateManager));
stateManager.addListener(new UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted(stateManager));
stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
@ -14,7 +14,9 @@ public class StateUtils {
stateManager.addActivityVisitor(new UpdateCostsAtAllLevels(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
stateManager.addActivityVisitor(new UpdateOccuredDeliveriesAtActivityLevel(stateManager));
stateManager.addActivityVisitor(new UpdateLatestOperationStartTimeAtActLocations(stateManager, vrp.getTransportCosts()));
stateManager.addActivityVisitor(new UpdateFuturePickupsAtActivityLevel(stateManager));
}

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

@ -82,7 +82,7 @@ class UpdateCostsAtAllLevels implements ActivityVisitor,StateUpdater{
totalOperationCost += transportCost;
totalOperationCost += actCost;
states.putActivityState(act, StateIdFactory.COSTS, new StateImpl(totalOperationCost));
states.putActivityState(act, StateFactory.COSTS, new StateImpl(totalOperationCost));
prevAct = act;
startTimeAtPrevAct = timeTracker.getActEndTime();
@ -101,7 +101,7 @@ class UpdateCostsAtAllLevels implements ActivityVisitor,StateUpdater{
totalOperationCost += actCost;
// totalOperationCost += getFixCosts(vehicleRoute.getVehicle());
states.putRouteState(vehicleRoute, StateIdFactory.COSTS, new StateImpl(totalOperationCost));
states.putRouteState(vehicleRoute, StateFactory.COSTS, new StateImpl(totalOperationCost));
//this is rather strange and likely to change
vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getDriver());

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

@ -29,9 +29,9 @@ class UpdateCostsAtRouteLevel implements StateUpdater,JobInsertedListener, Inser
@Override
public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
// inRoute.getVehicleRouteCostCalculator().addTransportCost(additionalCosts);
double oldCosts = states.getRouteState(inRoute, StateIdFactory.COSTS).toDouble();
double oldCosts = states.getRouteState(inRoute, StateFactory.COSTS).toDouble();
oldCosts += additionalCosts;
states.putRouteState(inRoute, StateIdFactory.COSTS, new StateImpl(oldCosts));
states.putRouteState(inRoute, StateFactory.COSTS, new StateImpl(oldCosts));
}
@Override
@ -52,7 +52,7 @@ class UpdateCostsAtRouteLevel implements StateUpdater,JobInsertedListener, Inser
for(VehicleRoute route : vehicleRoutes){
if(route.isEmpty()) continue;
route.getVehicleRouteCostCalculator().reset();
route.getVehicleRouteCostCalculator().addOtherCost(states.getRouteState(route, StateIdFactory.COSTS).toDouble());
route.getVehicleRouteCostCalculator().addOtherCost(states.getRouteState(route, StateFactory.COSTS).toDouble());
route.getVehicleRouteCostCalculator().price(route.getVehicle());
// forwardInTime.iterate(route);
}

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

@ -25,7 +25,7 @@ class UpdateEarliestStartTimeWindowAtActLocations implements ActivityVisitor,Sta
@Override
public void visit(TourActivity activity) {
timeTracker.visit(activity);
states.putActivityState(activity, StateIdFactory.EARLIEST_OPERATION_START_TIME, new StateImpl(Math.max(timeTracker.getActArrTime(), activity.getTheoreticalEarliestOperationStartTime())));
states.putActivityState(activity, StateFactory.EARLIEST_OPERATION_START_TIME, new StateImpl(Math.max(timeTracker.getActArrTime(), activity.getTheoreticalEarliestOperationStartTime())));
}

3
jsprit-core/src/main/java/algorithms/UpdateFuturePickupsAtActivityLevel.java
View file

@ -1,6 +1,5 @@
package algorithms;
import algorithms.StateManager.StateImpl;
import basics.route.PickupActivity;
import basics.route.ServiceActivity;
import basics.route.TourActivity;
@ -23,7 +22,7 @@ class UpdateFuturePickupsAtActivityLevel implements ReverseActivityVisitor, Stat
@Override
public void visit(TourActivity act) {
stateManager.putActivityState(act, StateIdFactory.FUTURE_PICKS, new StateImpl(futurePicks));
stateManager.putActivityState(act, StateFactory.FUTURE_PICKS, StateFactory.createState(futurePicks));
if(act instanceof PickupActivity || act instanceof ServiceActivity){
futurePicks += act.getCapacityDemand();
}

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

@ -39,7 +39,7 @@ class UpdateLatestOperationStartTimeAtActLocations implements ReverseActivityVis
double potentialLatestArrivalTimeAtCurrAct = latestArrTimeAtPrevAct - transportCosts.getBackwardTransportTime(activity.getLocationId(), prevAct.getLocationId(), latestArrTimeAtPrevAct, route.getDriver(),route.getVehicle()) - activity.getOperationTime();
double latestArrivalTime = Math.min(activity.getTheoreticalLatestOperationStartTime(), potentialLatestArrivalTimeAtCurrAct);
states.putActivityState(activity, StateIdFactory.LATEST_OPERATION_START_TIME, new StateImpl(latestArrivalTime));
states.putActivityState(activity, StateFactory.LATEST_OPERATION_START_TIME, new StateImpl(latestArrivalTime));
latestArrTimeAtPrevAct = latestArrivalTime;
prevAct = activity;

9
jsprit-core/src/main/java/algorithms/UpdateLoadAtActivityLevel.java
View file

@ -28,14 +28,14 @@ class UpdateLoadAtActivityLevel implements ActivityVisitor, StateUpdater {
*
* <p>Thus it DEPENDS on StateTypes.LOAD_AT_DEPOT
*
* <p>If you want to update StateTypes.LOAD_AT_DEPOT see {@link InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts}, {@link UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted}
* <p>If you want to update StateTypes.LOAD_AT_DEPOT see {@link UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts}, {@link UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted}
*
* <p>The loads can be retrieved by <br>
* <code>stateManager.getActivityState(activity,StateTypes.LOAD);</code>
*
*
*
* @see {@link InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts}, {@link UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted}
* @see {@link UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts}, {@link UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted}
* @author stefan
*
*/
@ -46,20 +46,21 @@ class UpdateLoadAtActivityLevel implements ActivityVisitor, StateUpdater {
@Override
public void begin(VehicleRoute route) {
currentLoad = (int) stateManager.getRouteState(route, StateIdFactory.LOAD_AT_BEGINNING).toDouble();
currentLoad = (int) stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble();
this.route = route;
}
@Override
public void visit(TourActivity act) {
currentLoad += act.getCapacityDemand();
stateManager.putActivityState(act, StateIdFactory.LOAD, new StateImpl(currentLoad));
stateManager.putActivityState(act, StateFactory.LOAD, StateFactory.createState(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., state)
currentLoad = 0;
}
}

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

@ -25,12 +25,12 @@ class UpdateLoadAtAllLevels implements ActivityVisitor,StateUpdater{
@Override
public void visit(TourActivity activity) {
load += (double)activity.getCapacityDemand();
states.putActivityState(activity, StateIdFactory.LOAD, new StateImpl(load));
states.putActivityState(activity, StateFactory.LOAD, new StateImpl(load));
}
@Override
public void finish() {
states.putRouteState(vehicleRoute, StateIdFactory.LOAD, new StateImpl(load));
states.putRouteState(vehicleRoute, StateFactory.LOAD, new StateImpl(load));
load=0;
vehicleRoute = null;
}

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

@ -35,8 +35,8 @@ class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsList
if(!(job2insert instanceof Service)){
return;
}
double oldLoad = states.getRouteState(inRoute, StateIdFactory.LOAD).toDouble();
states.putRouteState(inRoute, StateIdFactory.LOAD, new StateImpl(oldLoad + job2insert.getCapacityDemand()));
double oldLoad = states.getRouteState(inRoute, StateFactory.LOAD).toDouble();
states.putRouteState(inRoute, StateFactory.LOAD, StateFactory.createState(oldLoad + job2insert.getCapacityDemand()));
}
@Override
@ -46,7 +46,7 @@ class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsList
for(Job j : route.getTourActivities().getJobs()){
load += j.getCapacityDemand();
}
states.putRouteState(route, StateIdFactory.LOAD, new StateImpl(load));
states.putRouteState(route, StateFactory.LOAD, new StateImpl(load));
}
}

8
jsprit-core/src/main/java/algorithms/InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts.java → jsprit-core/src/main/java/algorithms/UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts.java
View file

@ -20,7 +20,7 @@ import basics.route.VehicleRoute;
*
* @param stateManager
*/
class InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts implements InsertionStartsListener {
class UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts implements InsertionStartsListener {
private StateManager stateManager;
@ -34,7 +34,7 @@ class InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts implements Insertio
*
* @param stateManager
*/
public InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts(StateManager stateManager) {
public UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts(StateManager stateManager) {
super();
this.stateManager = stateManager;
}
@ -50,8 +50,8 @@ class InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts implements Insertio
loadAtEnd += j.getCapacityDemand();
}
}
stateManager.putRouteState(route, StateIdFactory.LOAD_AT_BEGINNING, new StateImpl(loadAtDepot));
stateManager.putRouteState(route, StateIdFactory.LOAD, new StateImpl(loadAtEnd));
stateManager.putRouteState(route, StateFactory.LOAD_AT_BEGINNING, StateFactory.createState(loadAtDepot));
stateManager.putRouteState(route, StateFactory.LOAD_AT_END, StateFactory.createState(loadAtEnd));
}
@Override

8
jsprit-core/src/main/java/algorithms/UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted.java
View file

@ -38,14 +38,14 @@ class UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted implements JobInsert
@Override
public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
if(job2insert instanceof Delivery){
int loadAtDepot = (int) stateManager.getRouteState(inRoute, StateIdFactory.LOAD_AT_BEGINNING).toDouble();
int loadAtDepot = (int) stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING).toDouble();
// log.info("loadAtDepot="+loadAtDepot);
stateManager.putRouteState(inRoute, StateIdFactory.LOAD_AT_BEGINNING, new StateImpl(loadAtDepot + job2insert.getCapacityDemand()));
stateManager.putRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING, StateFactory.createState(loadAtDepot + job2insert.getCapacityDemand()));
}
else if(job2insert instanceof Pickup || job2insert instanceof Service){
int loadAtEnd = (int) stateManager.getRouteState(inRoute, StateIdFactory.LOAD).toDouble();
int loadAtEnd = (int) stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_END).toDouble();
// log.info("loadAtEnd="+loadAtEnd);
stateManager.putRouteState(inRoute, StateIdFactory.LOAD, new StateImpl(loadAtEnd + job2insert.getCapacityDemand()));
stateManager.putRouteState(inRoute, StateFactory.LOAD_AT_END, StateFactory.createState(loadAtEnd + job2insert.getCapacityDemand()));
}
}

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

@ -0,0 +1,68 @@
package algorithms;
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>If you want to update StateTypes.LOAD_AT_DEPOT see {@link UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts}, {@link UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted}
*
* <p>The loads can be retrieved by <br>
* <code>stateManager.getActivityState(activity,StateTypes.LOAD);</code>
*
*
*
* @see {@link UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts}, {@link UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted}
* @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;
}
}

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

@ -25,7 +25,7 @@ class UpdateOccuredDeliveriesAtActivityLevel implements ActivityVisitor, StateUp
if(act instanceof DeliveryActivity){
deliveries += Math.abs(act.getCapacityDemand());
}
stateManager.putActivityState(act, StateIdFactory.PAST_DELIVERIES, new StateImpl(deliveries));
stateManager.putActivityState(act, StateFactory.PAST_DELIVERIES, StateFactory.createState(deliveries));
assert deliveries >= 0 : "deliveries < 0";
assert deliveries <= route.getVehicle().getCapacity() : "deliveries > vehicleCap";
}

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

@ -0,0 +1,39 @@
package algorithms;
import java.util.ArrayList;
import java.util.Collection;
import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem;
import basics.algo.SearchStrategyManager;
import basics.algo.VehicleRoutingAlgorithmListener;
public class VehicleRoutingAlgorithmBuilder {
private VehicleRoutingProblem vrp;
private SearchStrategyManager searchStrategyManager;
private StateManager stateManager;
private Collection<VehicleRoutingAlgorithmListener> listeners = new ArrayList<VehicleRoutingAlgorithmListener>();
public VehicleRoutingAlgorithmBuilder(VehicleRoutingProblem vrp, SearchStrategyManager searchStrategyManager, StateManager stateManager) {
super();
this.vrp = vrp;
this.searchStrategyManager = searchStrategyManager;
this.stateManager = stateManager;
}
public void addListener(VehicleRoutingAlgorithmListener listener){
listeners.add(listener);
}
public VehicleRoutingAlgorithm build(){
VehicleRoutingAlgorithm algorithm = new VehicleRoutingAlgorithm(vrp, searchStrategyManager);
algorithm.getAlgorithmListeners().addListener(stateManager);
algorithm.getSearchStrategyManager().addSearchStrategyModuleListener(stateManager);
return algorithm;
}
}

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

@ -509,7 +509,7 @@ public class VehicleRoutingAlgorithms {
// routeChangedListener.addVisitor(new StateUpdates.UpdateLatestOperationStartTimeAtActLocations(stateManager, vrp.getTransportCosts()));
// routeChangedListener.addVisitor(new StateUpdates.UpdateFuturePickupsAtActivityLevel(stateManager));
stateManager.addListener(new InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts(stateManager));
stateManager.addListener(new UpdateLoadsAtStartAndEndOfRouteWhenInsertionStarts(stateManager));
stateManager.addListener(new UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted(stateManager));
stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
@ -550,7 +550,7 @@ public class VehicleRoutingAlgorithms {
double costs = 0.0;
for(VehicleRoute route : solution.getRoutes()){
costs += stateManager.getRouteState(route, StateIdFactory.COSTS).toDouble() + getFixedCosts(route.getVehicle());
costs += stateManager.getRouteState(route, StateFactory.COSTS).toDouble() + getFixedCosts(route.getVehicle());
}
solution.setCost(costs);

6
jsprit-core/src/main/java/algorithms/CalculatesVehTypeDepServiceInsertion.java → jsprit-core/src/main/java/algorithms/VehicleTypeDependentJobInsertionCalculator.java
View file

@ -30,15 +30,15 @@ import basics.route.VehicleRoute;
final class CalculatesVehTypeDepServiceInsertion implements JobInsertionCalculator{
final class VehicleTypeDependentJobInsertionCalculator implements JobInsertionCalculator{
private Logger logger = Logger.getLogger(CalculatesVehTypeDepServiceInsertion.class);
private Logger logger = Logger.getLogger(VehicleTypeDependentJobInsertionCalculator.class);
private final VehicleFleetManager fleetManager;
private final JobInsertionCalculator insertionCalculator;
public CalculatesVehTypeDepServiceInsertion(final VehicleFleetManager fleetManager, final JobInsertionCalculator jobInsertionCalc) {
public VehicleTypeDependentJobInsertionCalculator(final VehicleFleetManager fleetManager, final JobInsertionCalculator jobInsertionCalc) {
this.fleetManager = fleetManager;
this.insertionCalculator = jobInsertionCalc;
logger.info("inialise " + this);