merge min-waiting-time branch

jsprit-core/src/main/java/jsprit/core/algorithm/PrettyAlgorithmBuilder.java

@@ -91,8 +91,8 @@ public class PrettyAlgorithmBuilder {
             constraintManager.addSkillsConstraint();
             stateManager.updateLoadStates();
             stateManager.updateTimeWindowStates();
-            UpdateVehicleDependentPracticalTimeWindows tw_updater = new UpdateVehicleDependentPracticalTimeWindows(stateManager, vrp.getTransportCosts());
+            UpdateVehicleDependentPracticalTimeWindows twUpdater = new UpdateVehicleDependentPracticalTimeWindows(stateManager, vrp.getTransportCosts());
-            tw_updater.setVehiclesToUpdate(new UpdateVehicleDependentPracticalTimeWindows.VehiclesToUpdate() {
+            twUpdater.setVehiclesToUpdate(new UpdateVehicleDependentPracticalTimeWindows.VehiclesToUpdate() {
 
                 Map<VehicleTypeKey, Vehicle> uniqueTypes = new HashMap<VehicleTypeKey, Vehicle>();
 
@@ -109,12 +109,14 @@ public class PrettyAlgorithmBuilder {
                     vehicles.addAll(uniqueTypes.values());
                     return vehicles;
                 }
+
             });
-            stateManager.addStateUpdater(tw_updater);
+            stateManager.addStateUpdater(twUpdater);
             stateManager.updateSkillStates();
             stateManager.addStateUpdater(new UpdateEndLocationIfRouteIsOpen());
             stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS));
             stateManager.addStateUpdater(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
+            stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts()));
         }
         VehicleRoutingAlgorithm vra = new VehicleRoutingAlgorithm(vrp, searchStrategyManager);
         vra.addListener(stateManager);

jsprit-core/src/main/java/jsprit/core/algorithm/VehicleRoutingAlgorithm.java

@@ -20,6 +20,7 @@ import jsprit.core.algorithm.SearchStrategy.DiscoveredSolution;
 import jsprit.core.algorithm.listener.*;
 import jsprit.core.algorithm.termination.PrematureAlgorithmTermination;
 import jsprit.core.problem.VehicleRoutingProblem;
+import jsprit.core.problem.job.Job;
 import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
 import jsprit.core.problem.solution.route.VehicleRoute;
 import jsprit.core.problem.solution.route.activity.TourActivity;
@@ -35,6 +36,7 @@ import java.util.Collection;
  * Algorithm that solves a {@link VehicleRoutingProblem}.
  *
  * @author stefan schroeder
+ *
  */
 public class VehicleRoutingAlgorithm {
 
@@ -42,14 +44,14 @@ public class VehicleRoutingAlgorithm {
 
         private Collection<PrematureAlgorithmTermination> terminationCriteria = new ArrayList<PrematureAlgorithmTermination>();
 
-        void addTermination(PrematureAlgorithmTermination termination) {
+        void addTermination(PrematureAlgorithmTermination termination){
             terminationCriteria.add(termination);
         }
 
         @Override
         public boolean isPrematureBreak(DiscoveredSolution discoveredSolution) {
-            for (PrematureAlgorithmTermination termination : terminationCriteria) {
+            for(PrematureAlgorithmTermination termination : terminationCriteria){
-                if (termination.isPrematureBreak(discoveredSolution)) {
+                if(termination.isPrematureBreak(discoveredSolution)){
                     return true;
                 }
             }
@@ -194,14 +196,15 @@ public class VehicleRoutingAlgorithm {
         Collection<VehicleRoutingProblemSolution> solutions = new ArrayList<VehicleRoutingProblemSolution>(initialSolutions);
         algorithmStarts(problem, solutions);
         bestEver = Solutions.bestOf(solutions);
+		if(logger.isTraceEnabled()) log(solutions);
         logger.info("iterations start");
-        for (int i = 0; i < maxIterations; i++) {
+		for(int i=0;i< maxIterations;i++){
-            iterationStarts(i + 1, problem, solutions);
+			iterationStarts(i+1,problem,solutions);
-            logger.debug("start iteration: {}", i);
+			logger.debug("start iteration: {}",i);
 			counter.incCounter();
 			SearchStrategy strategy = searchStrategyManager.getRandomStrategy();
 			DiscoveredSolution discoveredSolution = strategy.run(problem, solutions);
-            logger.trace("discovered solution: {}", discoveredSolution);
+			if(logger.isTraceEnabled()) log(discoveredSolution);
             memorizeIfBestEver(discoveredSolution);
             selectedStrategy(discoveredSolution, problem, solutions);
             if (terminationManager.isPrematureBreak(discoveredSolution)) {
@@ -222,6 +225,39 @@ public class VehicleRoutingAlgorithm {
         if (bestEver != null) solutions.add(bestEver);
     }
 
+    private void log(Collection<VehicleRoutingProblemSolution> solutions) {
+		for(VehicleRoutingProblemSolution sol : solutions) log(sol);
+	}
+
+	private void log(VehicleRoutingProblemSolution solution){
+		logger.trace("solution costs: {}",solution.getCost());
+		for(VehicleRoute r : solution.getRoutes()){
+			StringBuilder b = new StringBuilder();
+			b.append(r.getVehicle().getId()).append(" : ").append("[ ");
+			for(TourActivity act : r.getActivities()){
+				if(act instanceof TourActivity.JobActivity){
+					b.append(((TourActivity.JobActivity) act).getJob().getId()).append(" ");
+				}
+			}
+			b.append("]");
+			logger.trace(b.toString());
+		}
+		StringBuilder b = new StringBuilder();
+		b.append("unassigned : [ ");
+		for(Job j : solution.getUnassignedJobs()){
+			b.append(j.getId()).append(" ");
+		}
+		b.append("]");
+		logger.trace(b.toString());
+	}
+
+	private void log(DiscoveredSolution discoveredSolution) {
+		logger.trace("discovered solution: {}",discoveredSolution);
+		log(discoveredSolution.getSolution());
+	}
+
+
+
     private void memorizeIfBestEver(DiscoveredSolution discoveredSolution) {
         if (discoveredSolution == null) return;
         if (bestEver == null) bestEver = discoveredSolution.getSolution();

jsprit-core/src/main/java/jsprit/core/algorithm/box/Jsprit.java

@@ -40,11 +40,11 @@ public class Jsprit {
 
         String name;
 
-        Construction(String name) {
+        Construction(String name){
             this.name = name;
         }
 
-        public String toString() {
+        public String toString(){
             return name;
         }
 
@@ -63,11 +63,11 @@ public class Jsprit {
 
         String strategyName;
 
-        Strategy(String strategyName) {
+        Strategy(String strategyName){
             this.strategyName = strategyName;
         }
 
-        public String toString() {
+        public String toString(){
             return strategyName;
         }
     }
@@ -97,17 +97,17 @@ public class Jsprit {
 
         String paraName;
 
-        Parameter(String name) {
+        Parameter(String name){
             this.paraName = name;
         }
 
-        public String toString() {
+        public String toString(){
             return paraName;
         }
 
     }
 
-    public static VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vehicleRoutingProblem) {
+    public static VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vehicleRoutingProblem){
         return Jsprit.Builder.newInstance(vehicleRoutingProblem).buildAlgorithm();
     }
 
@@ -131,53 +131,53 @@ public class Jsprit {
 
         private Random random = RandomNumberGeneration.newInstance();
 
-        public static Builder newInstance(VehicleRoutingProblem vrp) {
+        public static Builder newInstance(VehicleRoutingProblem vrp){
             return new Builder(vrp);
         }
 
-        private Builder(VehicleRoutingProblem vrp) {
+        private Builder(VehicleRoutingProblem vrp){
             this.vrp = vrp;
             properties = new Properties(createDefaultProperties());
         }
 
         private Properties createDefaultProperties() {
             Properties defaults = new Properties();
-            defaults.put(Strategy.RADIAL_BEST.toString(), "0.");
+            defaults.put(Strategy.RADIAL_BEST.toString(),"0.");
-            defaults.put(Strategy.RADIAL_REGRET.toString(), ".5");
+            defaults.put(Strategy.RADIAL_REGRET.toString(),".5");
-            defaults.put(Strategy.RANDOM_BEST.toString(), ".5");
+            defaults.put(Strategy.RANDOM_BEST.toString(),".5");
-            defaults.put(Strategy.RANDOM_REGRET.toString(), ".5");
+            defaults.put(Strategy.RANDOM_REGRET.toString(),".5");
-            defaults.put(Strategy.WORST_BEST.toString(), "0.");
+            defaults.put(Strategy.WORST_BEST.toString(),"0.");
-            defaults.put(Strategy.WORST_REGRET.toString(), "1.");
+            defaults.put(Strategy.WORST_REGRET.toString(),"1.");
-            defaults.put(Strategy.CLUSTER_BEST.toString(), "0.");
+            defaults.put(Strategy.CLUSTER_BEST.toString(),"0.");
-            defaults.put(Strategy.CLUSTER_REGRET.toString(), "1.");
+            defaults.put(Strategy.CLUSTER_REGRET.toString(),"1.");
-            defaults.put(Parameter.FIXED_COST_PARAM.toString(), "0.");
+            defaults.put(Parameter.FIXED_COST_PARAM.toString(),"0.");
-            defaults.put(Parameter.VEHICLE_SWITCH.toString(), "true");
+            defaults.put(Parameter.VEHICLE_SWITCH.toString(),"true");
-            defaults.put(Parameter.ITERATIONS.toString(), "2000");
+            defaults.put(Parameter.ITERATIONS.toString(),"2000");
-            defaults.put(Parameter.REGRET_DISTANCE_SCORER.toString(), ".05");
+            defaults.put(Parameter.REGRET_DISTANCE_SCORER.toString(),".05");
-            defaults.put(Parameter.REGRET_TIME_WINDOW_SCORER.toString(), "-.1");
+            defaults.put(Parameter.REGRET_TIME_WINDOW_SCORER.toString(),"-.1");
-            defaults.put(Parameter.THREADS.toString(), "1");
+            defaults.put(Parameter.THREADS.toString(),"1");
-            int minShare = (int) Math.min(20, Math.max(3, vrp.getJobs().size() * 0.05));
+            int minShare = (int)Math.min(20, Math.max(3,vrp.getJobs().size() * 0.05));
-            int maxShare = (int) Math.min(50, Math.max(5, vrp.getJobs().size() * 0.3));
+            int maxShare = (int)Math.min(50, Math.max(5,vrp.getJobs().size() * 0.3));
-            defaults.put(Parameter.RADIAL_MIN_SHARE.toString(), String.valueOf(minShare));
+            defaults.put(Parameter.RADIAL_MIN_SHARE.toString(),String.valueOf(minShare));
-            defaults.put(Parameter.RADIAL_MAX_SHARE.toString(), String.valueOf(maxShare));
+            defaults.put(Parameter.RADIAL_MAX_SHARE.toString(),String.valueOf(maxShare));
-            defaults.put(Parameter.WORST_MIN_SHARE.toString(), String.valueOf(minShare));
+            defaults.put(Parameter.WORST_MIN_SHARE.toString(),String.valueOf(minShare));
-            defaults.put(Parameter.WORST_MAX_SHARE.toString(), String.valueOf(maxShare));
+            defaults.put(Parameter.WORST_MAX_SHARE.toString(),String.valueOf(maxShare));
-            defaults.put(Parameter.CLUSTER_MIN_SHARE.toString(), String.valueOf(minShare));
+            defaults.put(Parameter.CLUSTER_MIN_SHARE.toString(),String.valueOf(minShare));
-            defaults.put(Parameter.CLUSTER_MAX_SHARE.toString(), String.valueOf(maxShare));
+            defaults.put(Parameter.CLUSTER_MAX_SHARE.toString(),String.valueOf(maxShare));
-            int minShare_ = (int) Math.min(70, Math.max(5, vrp.getJobs().size() * 0.5));
+            int minShare_ = (int)Math.min(70, Math.max(5,vrp.getJobs().size() * 0.5));
-            int maxShare_ = (int) Math.min(70, Math.max(5, vrp.getJobs().size() * 0.5));
+            int maxShare_ = (int)Math.min(70, Math.max(5,vrp.getJobs().size() * 0.5));
-            defaults.put(Parameter.RANDOM_REGRET_MIN_SHARE.toString(), String.valueOf(minShare_));
+            defaults.put(Parameter.RANDOM_REGRET_MIN_SHARE.toString(),String.valueOf(minShare_));
-            defaults.put(Parameter.RANDOM_REGRET_MAX_SHARE.toString(), String.valueOf(maxShare_));
+            defaults.put(Parameter.RANDOM_REGRET_MAX_SHARE.toString(),String.valueOf(maxShare_));
-            defaults.put(Parameter.RANDOM_BEST_MIN_SHARE.toString(), String.valueOf(minShare_));
+            defaults.put(Parameter.RANDOM_BEST_MIN_SHARE.toString(),String.valueOf(minShare_));
-            defaults.put(Parameter.RANDOM_BEST_MAX_SHARE.toString(), String.valueOf(maxShare_));
+            defaults.put(Parameter.RANDOM_BEST_MAX_SHARE.toString(),String.valueOf(maxShare_));
-            defaults.put(Parameter.THRESHOLD_ALPHA.toString(), String.valueOf(0.15));
+            defaults.put(Parameter.THRESHOLD_ALPHA.toString(),String.valueOf(0.15));
-            defaults.put(Parameter.THRESHOLD_INI.toString(), String.valueOf(0.03));
+            defaults.put(Parameter.THRESHOLD_INI.toString(),String.valueOf(0.03));
-            defaults.put(Parameter.INSERTION_NOISE_LEVEL.toString(), String.valueOf(0.15));
+            defaults.put(Parameter.INSERTION_NOISE_LEVEL.toString(),String.valueOf(0.15));
-            defaults.put(Parameter.INSERTION_NOISE_PROB.toString(), String.valueOf(0.2));
+            defaults.put(Parameter.INSERTION_NOISE_PROB.toString(),String.valueOf(0.2));
-            defaults.put(Parameter.RUIN_WORST_NOISE_LEVEL.toString(), String.valueOf(0.15));
+            defaults.put(Parameter.RUIN_WORST_NOISE_LEVEL.toString(),String.valueOf(0.15));
-            defaults.put(Parameter.RUIN_WORST_NOISE_PROB.toString(), String.valueOf(0.2));
+            defaults.put(Parameter.RUIN_WORST_NOISE_PROB.toString(),String.valueOf(0.2));
-            defaults.put(Parameter.VEHICLE_SWITCH.toString(), String.valueOf(true));
+            defaults.put(Parameter.VEHICLE_SWITCH.toString(),String.valueOf(true));
-            defaults.put(Parameter.CONSTRUCTION.toString(), Construction.REGRET_INSERTION.toString());
+            defaults.put(Parameter.CONSTRUCTION.toString(),Construction.REGRET_INSERTION.toString());
             return defaults;
         }
 
@@ -188,23 +188,23 @@ public class Jsprit {
             return this;
         }
 
-        public Builder setRandom(Random random) {
+        public Builder setRandom(Random random){
             this.random = random;
             return this;
         }
 
-        public Builder setProperty(String key, String value) {
+        public Builder setProperty(String key, String value){
-            properties.put(key, value);
+            properties.put(key,value);
             return this;
         }
 
-        public Builder setProperty(Parameter parameter, String value) {
+        public Builder setProperty(Parameter parameter, String value){
-            setProperty(parameter.toString(), value);
+            setProperty(parameter.toString(),value);
             return this;
         }
 
-        public Builder setProperty(Strategy strategy, String value) {
+        public Builder setProperty(Strategy strategy, String value){
-            setProperty(strategy.toString(), value);
+            setProperty(strategy.toString(),value);
             return this;
         }
 
@@ -224,7 +224,7 @@ public class Jsprit {
             return this;
         }
 
-        public VehicleRoutingAlgorithm buildAlgorithm() {
+        public VehicleRoutingAlgorithm buildAlgorithm(){
             return new Jsprit(this).create(vrp);
         }
 
@@ -245,15 +245,13 @@ public class Jsprit {
         }
 
         public RuinShareFactoryImpl(int minShare, int maxShare) {
-            if (maxShare < minShare)
+            if(maxShare < minShare) throw new IllegalArgumentException("maxShare must be equal or greater than minShare");
-                throw new IllegalArgumentException("maxShare must be equal or greater than minShare");
             this.minShare = minShare;
             this.maxShare = maxShare;
         }
 
         public RuinShareFactoryImpl(int minShare, int maxShare, Random random) {
-            if (maxShare < minShare)
+            if(maxShare < minShare) throw new IllegalArgumentException("maxShare must be equal or greater than minShare");
-                throw new IllegalArgumentException("maxShare must be equal or greater than minShare");
             this.minShare = minShare;
             this.maxShare = maxShare;
             this.random = random;
@@ -295,17 +293,18 @@ public class Jsprit {
         this.random = builder.random;
     }
 
-    private VehicleRoutingAlgorithm create(final VehicleRoutingProblem vrp) {
+    private VehicleRoutingAlgorithm create(final VehicleRoutingProblem vrp){
         VehicleFleetManager fm;
-        if (vrp.getFleetSize().equals(VehicleRoutingProblem.FleetSize.INFINITE)) {
+        if(vrp.getFleetSize().equals(VehicleRoutingProblem.FleetSize.INFINITE)){
             fm = new InfiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
-        } else fm = new FiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
+        }
+        else fm = new FiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
 
-        if (stateManager == null) {
+        if(stateManager == null){
             stateManager = new StateManager(vrp);
         }
-        if (constraintManager == null) {
+        if(constraintManager == null){
-            constraintManager = new ConstraintManager(vrp, stateManager);
+            constraintManager = new ConstraintManager(vrp,stateManager);
         }
 
         double noiseLevel = toDouble(getProperty(Parameter.INSERTION_NOISE_LEVEL.toString()));
@@ -317,7 +316,7 @@ public class Jsprit {
         JobNeighborhoods jobNeighborhoods = new JobNeighborhoodsFactory().createNeighborhoods(vrp, new AvgServiceAndShipmentDistance(vrp.getTransportCosts()), (int) (vrp.getJobs().values().size() * 0.5));
         jobNeighborhoods.initialise();
 
-        RuinRadial radial = new RuinRadial(vrp, vrp.getJobs().size(), jobNeighborhoods);
+        RuinRadial radial = new RuinRadial(vrp,vrp.getJobs().size(),jobNeighborhoods);
         radial.setRandom(random);
         radial.setRuinShareFactory(new RuinShareFactoryImpl(
                 toInteger(properties.getProperty(Parameter.RADIAL_MIN_SHARE.toString())),
@@ -325,7 +324,7 @@ public class Jsprit {
                         random)
         );
 
-        final RuinRandom random_for_regret = new RuinRandom(vrp, 0.5);
+        final RuinRandom random_for_regret = new RuinRandom(vrp,0.5);
         random_for_regret.setRandom(random);
         random_for_regret.setRuinShareFactory(new RuinShareFactoryImpl(
                         toInteger(properties.getProperty(Parameter.RANDOM_REGRET_MIN_SHARE.toString())),
@@ -333,7 +332,7 @@ public class Jsprit {
                         random)
         );
 
-        final RuinRandom random_for_best = new RuinRandom(vrp, 0.5);
+        final RuinRandom random_for_best = new RuinRandom(vrp,0.5);
         random_for_best.setRandom(random);
         random_for_best.setRuinShareFactory(new RuinShareFactoryImpl(
                         toInteger(properties.getProperty(Parameter.RANDOM_BEST_MIN_SHARE.toString())),
@@ -341,7 +340,7 @@ public class Jsprit {
                         random)
         );
 
-        final RuinWorst worst = new RuinWorst(vrp, (int) (vrp.getJobs().values().size() * 0.5));
+        final RuinWorst worst = new RuinWorst(vrp, (int) (vrp.getJobs().values().size()*0.5));
         worst.setRandom(random);
         worst.setRuinShareFactory(new RuinShareFactoryImpl(
                         toInteger(properties.getProperty(Parameter.WORST_MIN_SHARE.toString())),
@@ -354,16 +353,17 @@ public class Jsprit {
                 worst.setNoiseMaker(new NoiseMaker() {
 
                     public double makeNoise() {
-                        if (random.nextDouble() < toDouble(getProperty(Parameter.RUIN_WORST_NOISE_PROB.toString()))) {
+                        if(random.nextDouble() < toDouble(getProperty(Parameter.RUIN_WORST_NOISE_PROB.toString()))) {
                             return toDouble(getProperty(Parameter.RUIN_WORST_NOISE_LEVEL.toString()))
                                     * noiseMaker.maxCosts * random.nextDouble();
-                        } else return 0.;
+                        }
+                        else return 0.;
                     }
                 });
             }
         };
 
-        final RuinClusters clusters = new RuinClusters(vrp, (int) (vrp.getJobs().values().size() * 0.5), jobNeighborhoods);
+        final RuinClusters clusters = new RuinClusters(vrp,(int) (vrp.getJobs().values().size()*0.5),jobNeighborhoods);
         clusters.setRandom(random);
         clusters.setRuinShareFactory(new RuinShareFactoryImpl(
                         toInteger(properties.getProperty(Parameter.WORST_MIN_SHARE.toString())),
@@ -373,16 +373,16 @@ public class Jsprit {
 
         AbstractInsertionStrategy regret;
         final RegretInsertion.DefaultScorer scorer;
-        if (noThreads == null) {
+        if(noThreads == null){
             noThreads = toInteger(getProperty(Parameter.THREADS.toString()));
         }
-        if (noThreads > 1) {
+        if(noThreads > 1){
-            if (es == null) {
+            if(es == null){
                 setupExecutorInternally = true;
                 es = Executors.newFixedThreadPool(noThreads);
             }
         }
-        if (es != null) {
+        if(es != null) {
             RegretInsertionConcurrent regretInsertion = (RegretInsertionConcurrent) new InsertionBuilder(vrp, fm, stateManager, constraintManager)
                     .setInsertionStrategy(InsertionBuilder.Strategy.REGRET)
                     .setConcurrentMode(es, noThreads)
@@ -392,7 +392,8 @@ public class Jsprit {
             scorer = getRegretScorer(vrp);
             regretInsertion.setScoringFunction(scorer);
             regret = regretInsertion;
-        } else {
+        }
+        else {
             RegretInsertion regretInsertion = (RegretInsertion) new InsertionBuilder(vrp, fm, stateManager, constraintManager)
                     .setInsertionStrategy(InsertionBuilder.Strategy.REGRET)
                     .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString())))
@@ -405,14 +406,15 @@ public class Jsprit {
         regret.setRandom(random);
 
         AbstractInsertionStrategy best;
-        if (vrp.getJobs().size() < 250 || es == null) {
+        if(vrp.getJobs().size() < 250 || es == null) {
             BestInsertion bestInsertion = (BestInsertion) new InsertionBuilder(vrp, fm, stateManager, constraintManager)
                     .setInsertionStrategy(InsertionBuilder.Strategy.BEST)
                     .considerFixedCosts(Double.valueOf(properties.getProperty(Parameter.FIXED_COST_PARAM.toString())))
                     .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString())))
                     .build();
             best = bestInsertion;
-        } else {
+        }
+        else{
             BestInsertionConcurrent bestInsertion = (BestInsertionConcurrent) new InsertionBuilder(vrp, fm, stateManager, constraintManager)
                     .setInsertionStrategy(InsertionBuilder.Strategy.BEST)
                     .considerFixedCosts(Double.valueOf(properties.getProperty(Parameter.FIXED_COST_PARAM.toString())))
@@ -423,11 +425,11 @@ public class Jsprit {
         }
         best.setRandom(random);
 
-        final SchrimpfAcceptance schrimpfAcceptance = new SchrimpfAcceptance(1, toDouble(getProperty(Parameter.THRESHOLD_ALPHA.toString())));
+        final SchrimpfAcceptance schrimpfAcceptance = new SchrimpfAcceptance(1,toDouble(getProperty(Parameter.THRESHOLD_ALPHA.toString())));
         IterationStartsListener schrimpfThreshold = new IterationStartsListener() {
             @Override
             public void informIterationStarts(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
-                if (i == 1) {
+                if(i == 1){
                     double initialThreshold = Solutions.bestOf(solutions).getCost() * toDouble(getProperty(Parameter.THRESHOLD_INI.toString()));
                     schrimpfAcceptance.setInitialThreshold(initialThreshold);
                 }
@@ -435,34 +437,34 @@ public class Jsprit {
         };
 
         SolutionCostCalculator objectiveFunction = getObjectiveFunction(vrp, noiseMaker.maxCosts);
-        SearchStrategy radial_regret = new SearchStrategy(Strategy.RADIAL_REGRET.toString(), new SelectBest(), schrimpfAcceptance, objectiveFunction);
+        SearchStrategy radial_regret = new SearchStrategy(Strategy.RADIAL_REGRET.toString(),new SelectBest(),schrimpfAcceptance, objectiveFunction);
         radial_regret.addModule(new RuinAndRecreateModule(Strategy.RADIAL_REGRET.toString(), regret, radial));
 
-        SearchStrategy radial_best = new SearchStrategy(Strategy.RADIAL_BEST.toString(), new SelectBest(), schrimpfAcceptance, objectiveFunction);
+        SearchStrategy radial_best = new SearchStrategy(Strategy.RADIAL_BEST.toString(),new SelectBest(),schrimpfAcceptance,objectiveFunction);
-        radial_best.addModule(new RuinAndRecreateModule(Strategy.RADIAL_BEST.toString(), best, radial));
+        radial_best.addModule(new RuinAndRecreateModule(Strategy.RADIAL_BEST.toString(),best,radial));
 
-        SearchStrategy random_best = new SearchStrategy(Strategy.RANDOM_BEST.toString(), new SelectBest(), schrimpfAcceptance, objectiveFunction);
+        SearchStrategy random_best = new SearchStrategy(Strategy.RANDOM_BEST.toString(),new SelectBest(),schrimpfAcceptance,objectiveFunction);
-        random_best.addModule(new RuinAndRecreateModule(Strategy.RANDOM_BEST.toString(), best, random_for_best));
+        random_best.addModule(new RuinAndRecreateModule(Strategy.RANDOM_BEST.toString(),best,random_for_best));
 
-        SearchStrategy random_regret = new SearchStrategy(Strategy.RANDOM_REGRET.toString(), new SelectBest(), schrimpfAcceptance, objectiveFunction);
+        SearchStrategy random_regret = new SearchStrategy(Strategy.RANDOM_REGRET.toString(),new SelectBest(),schrimpfAcceptance,objectiveFunction);
-        random_regret.addModule(new RuinAndRecreateModule(Strategy.RANDOM_REGRET.toString(), regret, random_for_regret));
+        random_regret.addModule(new RuinAndRecreateModule(Strategy.RANDOM_REGRET.toString(),regret,random_for_regret));
 
-        SearchStrategy worst_regret = new SearchStrategy(Strategy.WORST_REGRET.toString(), new SelectBest(), schrimpfAcceptance, objectiveFunction);
+        SearchStrategy worst_regret = new SearchStrategy(Strategy.WORST_REGRET.toString(),new SelectBest(),schrimpfAcceptance,objectiveFunction);
-        worst_regret.addModule(new RuinAndRecreateModule(Strategy.WORST_REGRET.toString(), regret, worst));
+        worst_regret.addModule(new RuinAndRecreateModule(Strategy.WORST_REGRET.toString(),regret,worst));
 
-        SearchStrategy worst_best = new SearchStrategy(Strategy.WORST_BEST.toString(), new SelectBest(), schrimpfAcceptance, objectiveFunction);
+        SearchStrategy worst_best = new SearchStrategy(Strategy.WORST_BEST.toString(),new SelectBest(),schrimpfAcceptance,objectiveFunction);
-        worst_best.addModule(new RuinAndRecreateModule(Strategy.WORST_BEST.toString(), best, worst));
+        worst_best.addModule(new RuinAndRecreateModule(Strategy.WORST_BEST.toString(),best,worst));
 
-        final SearchStrategy clusters_regret = new SearchStrategy(Strategy.CLUSTER_REGRET.toString(), new SelectBest(), schrimpfAcceptance, objectiveFunction);
+        final SearchStrategy clusters_regret = new SearchStrategy(Strategy.CLUSTER_REGRET.toString(),new SelectBest(),schrimpfAcceptance,objectiveFunction);
-        clusters_regret.addModule(new RuinAndRecreateModule(Strategy.CLUSTER_REGRET.toString(), regret, clusters));
+        clusters_regret.addModule(new RuinAndRecreateModule(Strategy.CLUSTER_REGRET.toString(),regret,clusters));
 
-        final SearchStrategy clusters_best = new SearchStrategy(Strategy.CLUSTER_BEST.toString(), new SelectBest(), schrimpfAcceptance, objectiveFunction);
+        final SearchStrategy clusters_best = new SearchStrategy(Strategy.CLUSTER_BEST.toString(),new SelectBest(),schrimpfAcceptance,objectiveFunction);
-        clusters_best.addModule(new RuinAndRecreateModule(Strategy.CLUSTER_BEST.toString(), best, clusters));
+        clusters_best.addModule(new RuinAndRecreateModule(Strategy.CLUSTER_BEST.toString(),best,clusters));
 
 
         PrettyAlgorithmBuilder prettyBuilder  = PrettyAlgorithmBuilder.newInstance(vrp, fm, stateManager, constraintManager);
         prettyBuilder.setRandom(random);
-        if (addCoreConstraints) {
+        if(addCoreConstraints){
             prettyBuilder.addCoreStateAndConstraintStuff();
         }
         prettyBuilder.withStrategy(radial_regret, toDouble(getProperty(Strategy.RADIAL_REGRET.toString())))
@@ -471,11 +473,12 @@ public class Jsprit {
                 .withStrategy(random_regret, toDouble(getProperty(Strategy.RANDOM_REGRET.toString())))
                 .withStrategy(worst_best, toDouble(getProperty(Strategy.WORST_BEST.toString())))
                 .withStrategy(worst_regret, toDouble(getProperty(Strategy.WORST_REGRET.toString())))
-            .withStrategy(clusters_regret, toDouble(getProperty(Strategy.CLUSTER_REGRET.toString())))
+                .withStrategy(clusters_regret,toDouble(getProperty(Strategy.CLUSTER_REGRET.toString())))
-            .withStrategy(clusters_best, toDouble(getProperty(Strategy.CLUSTER_BEST.toString())));
+                .withStrategy(clusters_best,toDouble(getProperty(Strategy.CLUSTER_BEST.toString())));
-        if (getProperty(Parameter.CONSTRUCTION.toString()).equals(Construction.BEST_INSERTION.toString())) {
+        if (getProperty(Parameter.CONSTRUCTION.toString()).equals(Construction.BEST_INSERTION.toString())){
             prettyBuilder.constructInitialSolutionWith(best, objectiveFunction);
-        } else {
+        }
+        else{
             prettyBuilder.constructInitialSolutionWith(regret, objectiveFunction);
         }
 
@@ -501,7 +504,7 @@ public class Jsprit {
 
 
     private void handleExecutorShutdown(VehicleRoutingAlgorithm vra) {
-        if (setupExecutorInternally) {
+        if(setupExecutorInternally){
             vra.addListener(new AlgorithmEndsListener() {
 
                 @Override
@@ -511,7 +514,7 @@ public class Jsprit {
 
             });
         }
-        if (es != null) {
+        if(es != null) {
             Runtime.getRuntime().addShutdownHook(new Thread() {
                 public void run() {
                     if (!es.isShutdown()) {
@@ -523,7 +526,7 @@ public class Jsprit {
         }
     }
 
-    String getProperty(String key) {
+    String getProperty(String key){
         return properties.getProperty(key);
     }
 
@@ -540,20 +543,21 @@ public class Jsprit {
     }
 
     private SolutionCostCalculator getObjectiveFunction(final VehicleRoutingProblem vrp, final double maxCosts) {
-        if (objectiveFunction != null) return objectiveFunction;
+        if(objectiveFunction != null) return objectiveFunction;
 
         SolutionCostCalculator solutionCostCalculator = new SolutionCostCalculator() {
             @Override
             public double getCosts(VehicleRoutingProblemSolution solution) {
                 double costs = 0.;
-                for (VehicleRoute route : solution.getRoutes()) {
+                for(VehicleRoute route : solution.getRoutes()){
                     costs += route.getVehicle().getType().getVehicleCostParams().fix;
                     TourActivity prevAct = route.getStart();
-                    for (TourActivity act : route.getActivities()) {
+                    for(TourActivity act : route.getActivities()){
-                        costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(), act.getLocation(), prevAct.getEndTime(), route.getDriver(), route.getVehicle());
+                        costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),act.getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle());
+                        costs += vrp.getActivityCosts().getActivityCost(act,act.getArrTime(),route.getDriver(),route.getVehicle());
                         prevAct = act;
                     }
-                    costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(), route.getEnd().getLocation(), prevAct.getEndTime(), route.getDriver(), route.getVehicle());
+                    costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),route.getEnd().getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle());
                 }
                 costs += solution.getUnassignedJobs().size() * maxCosts * 2;
                 return costs;

jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureLocalActivityInsertionCalculator.java

@@ -0,0 +1,40 @@
+package jsprit.core.algorithm.recreate;
+
+import jsprit.core.algorithm.recreate.listener.InsertionStartsListener;
+import jsprit.core.algorithm.recreate.listener.JobInsertedListener;
+import jsprit.core.problem.VehicleRoutingProblem;
+import jsprit.core.problem.job.Job;
+import jsprit.core.problem.solution.route.VehicleRoute;
+
+import java.util.Collection;
+
+/**
+ * Created by schroeder on 22/07/15.
+ */
+public class ConfigureLocalActivityInsertionCalculator implements InsertionStartsListener, JobInsertedListener {
+
+    private VehicleRoutingProblem vrp;
+
+    private LocalActivityInsertionCostsCalculator localActivityInsertionCostsCalculator;
+
+    private int nuOfJobsToRecreate;
+
+    public ConfigureLocalActivityInsertionCalculator(VehicleRoutingProblem vrp, LocalActivityInsertionCostsCalculator localActivityInsertionCostsCalculator) {
+        this.vrp = vrp;
+        this.localActivityInsertionCostsCalculator = localActivityInsertionCostsCalculator;
+    }
+
+    @Override
+    public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
+        this.nuOfJobsToRecreate = unassignedJobs.size();
+        double completenessRatio = (1-((double)nuOfJobsToRecreate/(double)vrp.getJobs().values().size()));
+        localActivityInsertionCostsCalculator.setSolutionCompletenessRatio(Math.max(0.5,completenessRatio));
+    }
+
+    @Override
+    public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
+        nuOfJobsToRecreate--;
+        double completenessRatio = (1-((double)nuOfJobsToRecreate/(double)vrp.getJobs().values().size()));
+        localActivityInsertionCostsCalculator.setSolutionCompletenessRatio(Math.max(0.5,completenessRatio));
+    }
+}

jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculatorBuilder.java

@@ -32,6 +32,8 @@ import java.util.ArrayList;
 import java.util.List;
 
 
+
+
 public class JobInsertionCostsCalculatorBuilder {
 
 	private static class CalculatorPlusListeners {
@@ -95,7 +97,7 @@ public class JobInsertionCostsCalculatorBuilder {
 
 	/**
 	 * Constructs the builder.
-     * <p/>
+	 *
 	 * <p>Some calculators require information from the overall algorithm or the higher-level insertion procedure. Thus listeners inform them.
 	 * These listeners are cached in the according list and can thus be added when its time to add them.
 	 *
@@ -110,11 +112,11 @@ public class JobInsertionCostsCalculatorBuilder {
 
 	/**
 	 * Sets activityStates. MUST be set.
-     *
 	 * @param stateManager
+	 *
 	 * @return
 	 */
-    public JobInsertionCostsCalculatorBuilder setStateManager(RouteAndActivityStateGetter stateManager) {
+	public JobInsertionCostsCalculatorBuilder setStateManager(RouteAndActivityStateGetter stateManager){
 		this.states = stateManager;
 		return this;
 	}
@@ -125,7 +127,7 @@ public class JobInsertionCostsCalculatorBuilder {
 	 * @param vehicleRoutingProblem
 	 * @return
 	 */
-    public JobInsertionCostsCalculatorBuilder setVehicleRoutingProblem(VehicleRoutingProblem vehicleRoutingProblem) {
+	public JobInsertionCostsCalculatorBuilder setVehicleRoutingProblem(VehicleRoutingProblem vehicleRoutingProblem){
 		this.vrp = vehicleRoutingProblem;
 		return this;
 	}
@@ -136,25 +138,24 @@ public class JobInsertionCostsCalculatorBuilder {
 	 * @param fleetManager
 	 * @return
 	 */
-    public JobInsertionCostsCalculatorBuilder setVehicleFleetManager(VehicleFleetManager fleetManager) {
+	public JobInsertionCostsCalculatorBuilder setVehicleFleetManager(VehicleFleetManager fleetManager){
 		this.fleetManager = fleetManager;
 		return this;
 	}
 
 	/**
 	 * Sets a flag to build a calculator based on local calculations.
-     * <p/>
-     * <p>Insertion of a job and job-activity is evaluated based on the previous and next activity.
 	 *
+	 * <p>Insertion of a job and job-activity is evaluated based on the previous and next activity.
 	 * @param addDefaultCostCalc
 	 */
-    public JobInsertionCostsCalculatorBuilder setLocalLevel(boolean addDefaultCostCalc) {
+	public JobInsertionCostsCalculatorBuilder setLocalLevel(boolean addDefaultCostCalc){
 		local = true;
 		this.addDefaultCostCalc  = addDefaultCostCalc;
         return this;
 	}
 
-    public JobInsertionCostsCalculatorBuilder setActivityInsertionCostsCalculator(ActivityInsertionCostsCalculator activityInsertionCostsCalculator) {
+	public JobInsertionCostsCalculatorBuilder setActivityInsertionCostsCalculator(ActivityInsertionCostsCalculator activityInsertionCostsCalculator){
 		this.activityInsertionCostCalculator = activityInsertionCostsCalculator;
         return this;
 	}
@@ -166,7 +167,7 @@ public class JobInsertionCostsCalculatorBuilder {
 	 * @param memory
 	 * @param addDefaultMarginalCostCalc
 	 */
-    public JobInsertionCostsCalculatorBuilder setRouteLevel(int forwardLooking, int memory, boolean addDefaultMarginalCostCalc) {
+	public JobInsertionCostsCalculatorBuilder setRouteLevel(int forwardLooking, int memory, boolean addDefaultMarginalCostCalc){
 		local = false;
 		this.forwardLooking = forwardLooking;
 		this.memory = memory;
@@ -179,13 +180,13 @@ public class JobInsertionCostsCalculatorBuilder {
 	 *
 	 * @param weightOfFixedCosts
 	 */
-    public JobInsertionCostsCalculatorBuilder considerFixedCosts(double weightOfFixedCosts) {
+	public JobInsertionCostsCalculatorBuilder considerFixedCosts(double weightOfFixedCosts){
 		considerFixedCost = true;
 		this.weightOfFixedCost = weightOfFixedCosts;
         return this;
 	}
 
-    public JobInsertionCostsCalculatorBuilder experimentalTimeScheduler(double timeSlice, int neighbors) {
+	public JobInsertionCostsCalculatorBuilder experimentalTimeScheduler(double timeSlice, int neighbors){
 		timeScheduling = true;
 		this.timeSlice = timeSlice;
 		this.neighbors = neighbors;
@@ -198,33 +199,31 @@ public class JobInsertionCostsCalculatorBuilder {
 	 * @return jobInsertionCalculator.
 	 * @throws IllegalStateException if vrp == null or activityStates == null or fleetManager == null.
 	 */
-    public JobInsertionCostsCalculator build() {
+	public JobInsertionCostsCalculator build(){
-        if (vrp == null)
+		if(vrp == null) throw new IllegalStateException("vehicle-routing-problem is null, but it must be set (this.setVehicleRoutingProblem(vrp))");
-            throw new IllegalStateException("vehicle-routing-problem is null, but it must be set (this.setVehicleRoutingProblem(vrp))");
+		if(states == null) throw new IllegalStateException("states is null, but is must be set (this.setStateManager(states))");
-        if (states == null)
+		if(fleetManager == null) throw new IllegalStateException("fleetManager is null, but it must be set (this.setVehicleFleetManager(fleetManager))");
-            throw new IllegalStateException("states is null, but is must be set (this.setStateManager(states))");
-        if (fleetManager == null)
-            throw new IllegalStateException("fleetManager is null, but it must be set (this.setVehicleFleetManager(fleetManager))");
 		JobInsertionCostsCalculator baseCalculator = null;
 		CalculatorPlusListeners standardLocal = null;
-        if (local) {
+		if(local){
 			standardLocal = createStandardLocal(vrp, states);
-        } else {
+		}
+		else{
 			checkServicesOnly();
-            standardLocal = createStandardRoute(vrp, states, forwardLooking, memory);
+			standardLocal = createStandardRoute(vrp, states,forwardLooking,memory);
 		}
 		baseCalculator = standardLocal.getCalculator();
 		addAlgorithmListeners(standardLocal.getAlgorithmListener());
 		addInsertionListeners(standardLocal.getInsertionListener());
-        if (considerFixedCost) {
+		if(considerFixedCost){
 			CalculatorPlusListeners withFixed = createCalculatorConsideringFixedCosts(vrp, baseCalculator, states, weightOfFixedCost);
 			baseCalculator = withFixed.getCalculator();
 			addAlgorithmListeners(withFixed.getAlgorithmListener());
 			addInsertionListeners(withFixed.getInsertionListener());
 		}
-        if (timeScheduling) {
+		if(timeScheduling){
 //			baseCalculator = new CalculatesServiceInsertionWithTimeSchedulingInSlices(baseCalculator,timeSlice,neighbors);
-            CalculatesServiceInsertionWithTimeScheduling wts = new CalculatesServiceInsertionWithTimeScheduling(baseCalculator, timeSlice, neighbors);
+            CalculatesServiceInsertionWithTimeScheduling wts = new CalculatesServiceInsertionWithTimeScheduling(baseCalculator,timeSlice,neighbors);
             CalculatorPlusListeners calcPlusListeners = new CalculatorPlusListeners(wts);
             calcPlusListeners.getInsertionListener().add(new CalculatesServiceInsertionWithTimeScheduling.KnowledgeInjection(wts));
             addInsertionListeners(calcPlusListeners.getInsertionListener());
@@ -234,8 +233,8 @@ public class JobInsertionCostsCalculatorBuilder {
 	}
 
 	private void checkServicesOnly() {
-        for (Job j : vrp.getJobs().values()) {
+		for(Job j : vrp.getJobs().values()){
-            if (j instanceof Shipment) {
+			if(j instanceof Shipment){
 				throw new UnsupportedOperationException("currently the 'insert-on-route-level' option is only available for services (i.e. service, pickup, delivery), \n" +
 						"if you want to deal with shipments switch to option 'local-level' by either setting bestInsertionBuilder.setLocalLevel() or \n"
 						+ "by omitting the xml-tag '<level forwardLooking=2 memory=1>route</level>' when defining your insertionStrategy in algo-config.xml file");
@@ -245,25 +244,28 @@ public class JobInsertionCostsCalculatorBuilder {
 	}
 
 	private void addInsertionListeners(List<InsertionListener> list) {
-        for (InsertionListener iL : list) {
+		for(InsertionListener iL : list){
 			insertionListeners.add(iL);
 		}
 	}
 
 	private void addAlgorithmListeners(List<PrioritizedVRAListener> list) {
-        for (PrioritizedVRAListener aL : list) {
+		for(PrioritizedVRAListener aL : list){
 			algorithmListeners.add(aL);
 		}
 	}
 
-    private CalculatorPlusListeners createStandardLocal(final VehicleRoutingProblem vrp, RouteAndActivityStateGetter statesManager) {
+	private CalculatorPlusListeners createStandardLocal(final VehicleRoutingProblem vrp, RouteAndActivityStateGetter statesManager){
-        if (constraintManager == null) throw new IllegalStateException("constraint-manager is null");
+		if(constraintManager == null) throw new IllegalStateException("constraint-manager is null");
 
 		ActivityInsertionCostsCalculator actInsertionCalc;
-        if (activityInsertionCostCalculator == null && addDefaultCostCalc) {
+		ConfigureLocalActivityInsertionCalculator configLocal = null;
-            actInsertionCalc = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts());
+		if(activityInsertionCostCalculator == null && addDefaultCostCalc){
-        } else if (activityInsertionCostCalculator == null && !addDefaultCostCalc) {
+			actInsertionCalc = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), statesManager);
-            actInsertionCalc = new ActivityInsertionCostsCalculator() {
+			configLocal = new ConfigureLocalActivityInsertionCalculator(vrp, (LocalActivityInsertionCostsCalculator) actInsertionCalc);
+		}
+		else if(activityInsertionCostCalculator == null && !addDefaultCostCalc){
+			actInsertionCalc = new ActivityInsertionCostsCalculator(){
 
 				@Override
 				public double getCosts(JobInsertionContext iContext, TourActivity prevAct, TourActivity nextAct, TourActivity newAct,
@@ -272,7 +274,8 @@ public class JobInsertionCostsCalculatorBuilder {
 				}
 
 			};
-        } else {
+		}
+		else{
 			actInsertionCalc = activityInsertionCostCalculator;
 		}
 
@@ -295,10 +298,14 @@ public class JobInsertionCostsCalculatorBuilder {
 		switcher.put(Pickup.class, serviceInsertion);
 		switcher.put(Delivery.class, serviceInsertion);
 
-        return new CalculatorPlusListeners(switcher);
+		CalculatorPlusListeners calculatorPlusListeners = new CalculatorPlusListeners(switcher);
+		if(configLocal != null){
+			calculatorPlusListeners.insertionListener.add(configLocal);
+		}
+		return calculatorPlusListeners;
 	}
 
-    private CalculatorPlusListeners createCalculatorConsideringFixedCosts(VehicleRoutingProblem vrp, JobInsertionCostsCalculator baseCalculator, RouteAndActivityStateGetter activityStates2, double weightOfFixedCosts) {
+	private CalculatorPlusListeners createCalculatorConsideringFixedCosts(VehicleRoutingProblem vrp, JobInsertionCostsCalculator baseCalculator, RouteAndActivityStateGetter activityStates2, double weightOfFixedCosts){
 		final JobInsertionConsideringFixCostsCalculator withFixCost = new JobInsertionConsideringFixCostsCalculator(baseCalculator, activityStates2);
 		withFixCost.setWeightOfFixCost(weightOfFixedCosts);
 		CalculatorPlusListeners calcPlusListeners = new CalculatorPlusListeners(withFixCost);
@@ -306,16 +313,17 @@ public class JobInsertionCostsCalculatorBuilder {
 		return calcPlusListeners;
 	}
 
-    private CalculatorPlusListeners createStandardRoute(final VehicleRoutingProblem vrp, RouteAndActivityStateGetter activityStates2, int forwardLooking, int solutionMemory) {
+	private CalculatorPlusListeners createStandardRoute(final VehicleRoutingProblem vrp, RouteAndActivityStateGetter activityStates2, int forwardLooking, int solutionMemory){
 		ActivityInsertionCostsCalculator routeLevelCostEstimator;
-        if (activityInsertionCostCalculator == null && addDefaultCostCalc) {
+		if(activityInsertionCostCalculator == null && addDefaultCostCalc){
             RouteLevelActivityInsertionCostsEstimator routeLevelActivityInsertionCostsEstimator = new RouteLevelActivityInsertionCostsEstimator(vrp.getTransportCosts(), vrp.getActivityCosts(), activityStates2);
             routeLevelActivityInsertionCostsEstimator.setForwardLooking(forwardLooking);
             routeLevelCostEstimator = routeLevelActivityInsertionCostsEstimator;
-        } else if (activityInsertionCostCalculator == null && !addDefaultCostCalc) {
+		}
-            routeLevelCostEstimator = new ActivityInsertionCostsCalculator() {
+		else if(activityInsertionCostCalculator == null && !addDefaultCostCalc){
+			routeLevelCostEstimator = new ActivityInsertionCostsCalculator(){
 
-                final ActivityInsertionCosts noInsertionCosts = new ActivityInsertionCosts(0., 0.);
+				final ActivityInsertionCosts noInsertionCosts = new ActivityInsertionCosts(0.,0.);
 
 				@Override
 				public double getCosts(JobInsertionContext iContext, TourActivity prevAct, TourActivity nextAct, TourActivity newAct,
@@ -324,7 +332,8 @@ public class JobInsertionCostsCalculatorBuilder {
 				}
 
 			};
-        } else {
+		}
+		else{
 			routeLevelCostEstimator = activityInsertionCostCalculator;
 		}
         ServiceInsertionOnRouteLevelCalculator jobInsertionCalculator = new ServiceInsertionOnRouteLevelCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), routeLevelCostEstimator, constraintManager, constraintManager);
@@ -340,7 +349,7 @@ public class JobInsertionCostsCalculatorBuilder {
         return new CalculatorPlusListeners(jobInsertionCalculator);
 	}
 
-    private JobInsertionCostsCalculator createFinalInsertion(VehicleFleetManager fleetManager, JobInsertionCostsCalculator baseCalc, RouteAndActivityStateGetter activityStates2) {
+	private JobInsertionCostsCalculator createFinalInsertion(VehicleFleetManager fleetManager, JobInsertionCostsCalculator baseCalc, RouteAndActivityStateGetter activityStates2){
 		VehicleTypeDependentJobInsertionCalculator vehicleTypeDependentJobInsertionCalculator = new VehicleTypeDependentJobInsertionCalculator(vrp, fleetManager, baseCalc);
 		vehicleTypeDependentJobInsertionCalculator.setVehicleSwitchAllowed(allowVehicleSwitch);
 		return vehicleTypeDependentJobInsertionCalculator;

jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java

@@ -1,3 +1,4 @@
+
 /*******************************************************************************
  * Copyright (C) 2014  Stefan Schroeder
  *
@@ -17,33 +18,43 @@
 
 package jsprit.core.algorithm.recreate;
 
+import jsprit.core.algorithm.state.InternalStates;
 import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
 import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
 import jsprit.core.problem.misc.JobInsertionContext;
 import jsprit.core.problem.solution.route.activity.End;
 import jsprit.core.problem.solution.route.activity.TourActivity;
+import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter;
+import jsprit.core.problem.vehicle.Vehicle;
 import jsprit.core.util.CalculationUtils;
 
 /**
  * Calculates activity insertion costs locally, i.e. by comparing the additional costs of insertion the new activity k between
  * activity i (prevAct) and j (nextAct).
  * Additional costs are then basically calculated as delta c = c_ik + c_kj - c_ij.
- * <p/>
+ *
  * <p>Note once time has an effect on costs this class requires activity endTimes.
  *
  * @author stefan
+ *
  */
-class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCalculator {
+class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCalculator{
 
 	private VehicleRoutingTransportCosts routingCosts;
 
 	private VehicleRoutingActivityCosts activityCosts;
 
+	private double activityCostsWeight = 1.;
 
-    public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts) {
+	private double solutionCompletenessRatio = 1.;
+
+	private RouteAndActivityStateGetter stateManager;
+
+	public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, RouteAndActivityStateGetter stateManager) {
 		super();
 		this.routingCosts = routingCosts;
 		this.activityCosts = actCosts;
+		this.stateManager = stateManager;
 	}
 
 	@Override
@@ -53,34 +64,50 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal
 		double tp_time_prevAct_newAct = routingCosts.getTransportTime(prevAct.getLocation(), newAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
 		double newAct_arrTime = depTimeAtPrevAct + tp_time_prevAct_newAct;
 		double newAct_endTime = CalculationUtils.getActivityEndTime(newAct_arrTime, newAct);
+
 		double act_costs_newAct = activityCosts.getActivityCost(newAct, newAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
 
-        //open routes
+		if(isEnd(nextAct) && !toDepot(iFacts.getNewVehicle())) return tp_costs_prevAct_newAct;
-        if (nextAct instanceof End) {
-            if (!iFacts.getNewVehicle().isReturnToDepot()) {
-                return tp_costs_prevAct_newAct;
-            }
-        }
 
 		double tp_costs_newAct_nextAct = routingCosts.getTransportCost(newAct.getLocation(), nextAct.getLocation(), newAct_endTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
 		double tp_time_newAct_nextAct = routingCosts.getTransportTime(newAct.getLocation(), nextAct.getLocation(), newAct_endTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
 		double nextAct_arrTime = newAct_endTime + tp_time_newAct_nextAct;
+		double endTime_nextAct_new = CalculationUtils.getActivityEndTime(nextAct_arrTime, nextAct);
 		double act_costs_nextAct = activityCosts.getActivityCost(nextAct, nextAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
-        double totalCosts = tp_costs_prevAct_newAct + tp_costs_newAct_nextAct + act_costs_newAct + act_costs_nextAct;
 
-        double oldCosts;
+		double totalCosts = tp_costs_prevAct_newAct + tp_costs_newAct_nextAct + solutionCompletenessRatio * activityCostsWeight * (act_costs_newAct + act_costs_nextAct);
-        if (iFacts.getRoute().isEmpty()) {
+
+		double oldCosts = 0.;
+		if(iFacts.getRoute().isEmpty()){
 			double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocation(), nextAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
-            double arrTime_nextAct = routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
+			oldCosts += tp_costs_prevAct_nextAct;
-            double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
+		}
-            oldCosts = tp_costs_prevAct_nextAct + actCost_nextAct;
+		else{
-        } else {
 			double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle());
-            double arrTime_nextAct = routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle());
+			double arrTime_nextAct = depTimeAtPrevAct + routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle());
+			double endTime_nextAct_old = CalculationUtils.getActivityEndTime(arrTime_nextAct,nextAct);
 			double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle());
-            oldCosts = tp_costs_prevAct_nextAct + actCost_nextAct;
+
+			double endTimeDelay_nextAct = Math.max(0, endTime_nextAct_new - endTime_nextAct_old);
+			Double futureWaiting = stateManager.getActivityState(nextAct, iFacts.getRoute().getVehicle(), InternalStates.FUTURE_WAITING, Double.class);
+			if (futureWaiting == null) futureWaiting = 0.;
+			double waitingTime_savings_timeUnit = Math.min(futureWaiting, endTimeDelay_nextAct);
+			double waitingTime_savings = waitingTime_savings_timeUnit * iFacts.getRoute().getVehicle().getType().getVehicleCostParams().perWaitingTimeUnit;
+			oldCosts += solutionCompletenessRatio * activityCostsWeight * waitingTime_savings;
+			oldCosts += tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct;
 		}
 		return totalCosts - oldCosts;
 	}
 
+	private boolean toDepot(Vehicle newVehicle) {
+		return newVehicle.isReturnToDepot();
+	}
+
+	private boolean isEnd(TourActivity nextAct) {
+		return nextAct instanceof End;
+	}
+
+	public void setSolutionCompletenessRatio(double solutionCompletenessRatio) {
+		this.solutionCompletenessRatio = solutionCompletenessRatio;
+	}
 }

jsprit-core/src/main/java/jsprit/core/algorithm/recreate/VehicleTypeDependentJobInsertionCalculator.java

@@ -33,7 +33,7 @@ import java.util.HashSet;
 import java.util.Set;
 
 
-final class VehicleTypeDependentJobInsertionCalculator implements JobInsertionCostsCalculator {
+final class VehicleTypeDependentJobInsertionCalculator implements JobInsertionCostsCalculator{
 
 	private Logger logger = LogManager.getLogger(VehicleTypeDependentJobInsertionCalculator.class);
 
@@ -47,10 +47,11 @@ final class VehicleTypeDependentJobInsertionCalculator implements JobInsertionCo
 
 	/**
 	 * true if a vehicle(-type) is allowed to take over the whole route that was previously served by another vehicle
-     * <p/>
+	 *
 	 * <p>vehicleSwitch allowed makes sense if fleet consists of vehicles with different capacities such that one
 	 * can start with a small vehicle, but as the number of customers grows bigger vehicles can be operated, i.e.
 	 * bigger vehicles can take over the route that was previously served by a small vehicle.
+	 *
 	 */
 	private boolean vehicleSwitchAllowed = false;
 
@@ -59,12 +60,12 @@ final class VehicleTypeDependentJobInsertionCalculator implements JobInsertionCo
 		this.insertionCalculator = jobInsertionCalc;
 		this.vrp = vrp;
 		getInitialVehicleIds();
-        logger.debug("initialise {}", this);
+		logger.debug("initialise " + this);
 	}
 
 	private void getInitialVehicleIds() {
         Collection<VehicleRoute> initialVehicleRoutes = vrp.getInitialVehicleRoutes();
-        for (VehicleRoute initialRoute : initialVehicleRoutes) {
+        for(VehicleRoute initialRoute : initialVehicleRoutes){
 			initialVehicleIds.add(initialRoute.getVehicle().getId());
 		}
 	}
@@ -88,7 +89,7 @@ final class VehicleTypeDependentJobInsertionCalculator implements JobInsertionCo
 	 * @param vehicleSwitchAllowed the vehicleSwitchAllowed to set
 	 */
 	public void setVehicleSwitchAllowed(boolean vehicleSwitchAllowed) {
-        logger.debug("set vehicleSwitchAllowed to {}", vehicleSwitchAllowed);
+		logger.debug("set vehicleSwitchAllowed to " + vehicleSwitchAllowed);
 		this.vehicleSwitchAllowed = vehicleSwitchAllowed;
 	}
 
@@ -98,23 +99,24 @@ final class VehicleTypeDependentJobInsertionCalculator implements JobInsertionCo
 		InsertionData bestIData = InsertionData.createEmptyInsertionData();
 		double bestKnownCost_ = bestKnownCost;
 		Collection<Vehicle> relevantVehicles = new ArrayList<Vehicle>();
-        if (!(selectedVehicle instanceof NoVehicle)) {
+		if(!(selectedVehicle instanceof NoVehicle)) {
 			relevantVehicles.add(selectedVehicle);
-            if (vehicleSwitchAllowed && !isVehicleWithInitialRoute(selectedVehicle)) {
+			if(vehicleSwitchAllowed && !isVehicleWithInitialRoute(selectedVehicle)){
 				relevantVehicles.addAll(fleetManager.getAvailableVehicles(selectedVehicle));
 			}
-        } else { //if no vehicle has been assigned, i.e. it is an empty route
+		}
+		else{ //if no vehicle has been assigned, i.e. it is an empty route
 			relevantVehicles.addAll(fleetManager.getAvailableVehicles());
 		}
-        for (Vehicle v : relevantVehicles) {
+		for(Vehicle v : relevantVehicles){
 			double depTime;
-            if (v == selectedVehicle) depTime = currentRoute.getDepartureTime();
+			if(v == selectedVehicle) depTime = currentRoute.getDepartureTime();
 			else depTime = v.getEarliestDeparture();
 			InsertionData iData = insertionCalculator.getInsertionData(currentRoute, jobToInsert, v, depTime, selectedDriver, bestKnownCost_);
-            if (iData instanceof NoInsertionFound) {
+			if(iData instanceof NoInsertionFound) {
                 continue;
 			}
-            if (iData.getInsertionCost() < bestKnownCost_) {
+			if(iData.getInsertionCost() < bestKnownCost_){
 				bestIData = iData;
 				bestKnownCost_ = iData.getInsertionCost();
 			}

jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java

@@ -41,4 +41,12 @@ public class InternalStates {
     public final static StateId PAST_MAXLOAD = new StateFactory.StateIdImpl("past_max_load", 9);
 
     public static final StateId SKILLS = new StateFactory.StateIdImpl("skills", 10);
+
+	public static final StateId WAITING = new StateFactory.StateIdImpl("waiting",11);
+
+	public static final StateId TIME_SLACK = new StateFactory.StateIdImpl("time_slack",12);
+
+	public static final StateId FUTURE_WAITING = new StateFactory.StateIdImpl("future_waiting",13);
+
+	public static final StateId EARLIEST_WITHOUT_WAITING = new StateFactory.StateIdImpl("earliest_without_waiting",14);
 }

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateFutureWaitingTimes.java

@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * Copyright (C) 2014  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 jsprit.core.algorithm.state;
+
+import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
+import jsprit.core.problem.solution.route.VehicleRoute;
+import jsprit.core.problem.solution.route.activity.ReverseActivityVisitor;
+import jsprit.core.problem.solution.route.activity.TourActivity;
+
+/**
+ * Updates and memorizes latest operation start times at activities.
+ * 
+ * @author schroeder
+ *
+ */
+public class UpdateFutureWaitingTimes implements ReverseActivityVisitor, StateUpdater{
+
+	private StateManager states;
+
+	private VehicleRoute route;
+
+	private VehicleRoutingTransportCosts transportCosts;
+
+	private double futureWaiting;
+
+	public UpdateFutureWaitingTimes(StateManager states, VehicleRoutingTransportCosts tpCosts) {
+		super();
+		this.states = states;
+		this.transportCosts = tpCosts;
+	}
+
+	@Override
+	public void begin(VehicleRoute route) {
+		this.route = route;
+		this.futureWaiting = 0.;
+	}
+
+	@Override
+	public void visit(TourActivity activity) {
+		states.putInternalTypedActivityState(activity,route.getVehicle(),InternalStates.FUTURE_WAITING,futureWaiting);
+		futureWaiting += Math.max(activity.getTheoreticalEarliestOperationStartTime() - activity.getArrTime(),0);
+	}
+
+	@Override
+	public void finish() {}
+}

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java

@@ -19,15 +19,26 @@ package jsprit.core.algorithm.state;
 
 import jsprit.core.problem.Location;
 import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
+import jsprit.core.problem.solution.route.RouteVisitor;
 import jsprit.core.problem.solution.route.VehicleRoute;
-import jsprit.core.problem.solution.route.activity.ReverseActivityVisitor;
 import jsprit.core.problem.solution.route.activity.TourActivity;
 import jsprit.core.problem.vehicle.Vehicle;
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Iterator;
 
-public class UpdateVehicleDependentPracticalTimeWindows implements ReverseActivityVisitor, StateUpdater {
+public class UpdateVehicleDependentPracticalTimeWindows implements RouteVisitor, StateUpdater{
+
+    @Override
+    public void visit(VehicleRoute route) {
+        begin(route);
+        Iterator<TourActivity> revIterator = route.getTourActivities().reverseActivityIterator();
+        while(revIterator.hasNext()){
+            visit(revIterator.next());
+        }
+        finish();
+    }
 
     public static interface VehiclesToUpdate {
 
@@ -64,23 +75,23 @@ public class UpdateVehicleDependentPracticalTimeWindows implements ReverseActivi
         location_of_prevAct = new Location[stateManager.getMaxIndexOfVehicleTypeIdentifiers() + 1];
     }
 
-    public void setVehiclesToUpdate(VehiclesToUpdate vehiclesToUpdate) {
+    public void setVehiclesToUpdate(VehiclesToUpdate vehiclesToUpdate){
         this.vehiclesToUpdate = vehiclesToUpdate;
     }
 
-    @Override
+
     public void begin(VehicleRoute route) {
         this.route = route;
         vehicles = vehiclesToUpdate.get(route);
-        for (Vehicle vehicle : vehicles) {
+        for(Vehicle vehicle : vehicles){
             latest_arrTimes_at_prevAct[vehicle.getVehicleTypeIdentifier().getIndex()] = vehicle.getLatestArrival();
             location_of_prevAct[vehicle.getVehicleTypeIdentifier().getIndex()] = vehicle.getEndLocation();
         }
     }
 
-    @Override
+
     public void visit(TourActivity activity) {
-        for (Vehicle vehicle : vehicles) {
+        for(Vehicle vehicle : vehicles){
             double latestArrTimeAtPrevAct = latest_arrTimes_at_prevAct[vehicle.getVehicleTypeIdentifier().getIndex()];
             Location prevLocation = location_of_prevAct[vehicle.getVehicleTypeIdentifier().getIndex()];
             double potentialLatestArrivalTimeAtCurrAct = latestArrTimeAtPrevAct - transportCosts.getBackwardTransportTime(activity.getLocation(), prevLocation,
@@ -92,9 +103,8 @@ public class UpdateVehicleDependentPracticalTimeWindows implements ReverseActivi
         }
     }
 
-    @Override
+
-    public void finish() {
+    public void finish() {}
-    }
 
 }
 

jsprit-core/src/main/java/jsprit/core/problem/VehicleRoutingProblem.java

@@ -18,7 +18,7 @@ package jsprit.core.problem;
 
 import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
 import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
-import jsprit.core.problem.driver.Driver;
+import jsprit.core.problem.cost.WaitingTimeCosts;
 import jsprit.core.problem.job.Job;
 import jsprit.core.problem.job.Service;
 import jsprit.core.problem.job.Shipment;
@@ -41,15 +41,18 @@ import java.util.*;
 
 /**
  * Contains and defines the vehicle routing problem.
- * <p/>
+ *
  * <p>A routing problem is defined as jobs, vehicles, costs and constraints.
- * <p/>
+ *
  * <p> To construct the problem, use VehicleRoutingProblem.Builder. Get an instance of this by using the static method VehicleRoutingProblem.Builder.newInstance().
- * <p/>
+ *
  * <p>By default, fleetSize is INFINITE, transport-costs are calculated as euclidean-distance (CrowFlyCosts),
  * and activity-costs are set to zero.
  *
+ *
+ *
  * @author stefan schroeder
+ *
  */
 public class VehicleRoutingProblem {
 
@@ -57,38 +60,26 @@ public class VehicleRoutingProblem {
 	 * Builder to build the routing-problem.
 	 *
 	 * @author stefan schroeder
+	 *
 	 */
 	public static class Builder {
 
 
+
         /**
 		 * Returns a new instance of this builder.
 		 *
 		 * @return builder
 		 */
-        public static Builder newInstance() {
+		public static Builder newInstance(){ return new Builder(); }
-            return new Builder();
-        }
 
 		private VehicleRoutingTransportCosts transportCosts;
 
-        private VehicleRoutingActivityCosts activityCosts = new VehicleRoutingActivityCosts() {
+		private VehicleRoutingActivityCosts activityCosts = new WaitingTimeCosts();
 
-            @Override
+		private Map<String,Job> jobs = new LinkedHashMap<String, Job>();
-            public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) {
-                return 0;
-            }
 
-            @Override
+		private Map<String,Job> tentativeJobs = new LinkedHashMap<String,Job>();
-            public String toString() {
-                return "[name=defaultActivityCosts]";
-            }
-
-        };
-
-        private Map<String, Job> jobs = new LinkedHashMap<String, Job>();
-
-        private Map<String, Job> tentativeJobs = new LinkedHashMap<String, Job>();
 
 		private Set<String> jobsInInitialRoutes = new HashSet<String>();
 
@@ -107,9 +98,10 @@ public class VehicleRoutingProblem {
             @Override
             public List<AbstractActivity> createActivities(Job job) {
                 List<AbstractActivity> acts = new ArrayList<AbstractActivity>();
-                if (job instanceof Service) {
+                if(job instanceof Service){
                     acts.add(serviceActivityFactory.createActivity((Service) job));
-                } else if (job instanceof Shipment) {
+                }
+                else if(job instanceof Shipment){
                     acts.add(shipmentActivityFactory.createPickup((Shipment) job));
                     acts.add(shipmentActivityFactory.createDelivery((Shipment) job));
                 }
@@ -126,43 +118,42 @@ public class VehicleRoutingProblem {
 
         private int vehicleTypeIdIndexCounter = 1;
 
-        private Map<VehicleTypeKey, Integer> typeKeyIndices = new HashMap<VehicleTypeKey, Integer>();
+        private Map<VehicleTypeKey,Integer> typeKeyIndices = new HashMap<VehicleTypeKey, Integer>();
 
-        private Map<Job, List<AbstractActivity>> activityMap = new HashMap<Job, List<AbstractActivity>>();
+        private Map<Job,List<AbstractActivity>> activityMap = new HashMap<Job, List<AbstractActivity>>();
 
         private final DefaultShipmentActivityFactory shipmentActivityFactory = new DefaultShipmentActivityFactory();
 
         private final DefaultTourActivityFactory serviceActivityFactory = new DefaultTourActivityFactory();
 
-        private void incJobIndexCounter() {
+        private void incJobIndexCounter(){
             jobIndexCounter++;
         }
 
-        private void incActivityIndexCounter() {
+        private void incActivityIndexCounter(){
             activityIndexCounter++;
         }
 
-        private void incVehicleTypeIdIndexCounter() {
+        private void incVehicleTypeIdIndexCounter() { vehicleTypeIdIndexCounter++; }
-            vehicleTypeIdIndexCounter++;
-        }
 
 		/**
 		 * Returns the unmodifiable map of collected locations (mapped by their location-id).
 		 *
 		 * @return map with locations
 		 */
-        public Map<String, Coordinate> getLocationMap() {
+		public Map<String,Coordinate> getLocationMap(){
 			return Collections.unmodifiableMap(tentative_coordinates);
 		}
 
 		/**
 		 * Returns the locations collected SO FAR by this builder.
-         * <p/>
+		 *
 		 * <p>Locations are cached when adding a shipment, service, depot, vehicle.
 		 *
 		 * @return locations
-         */
+		 *
-        public Locations getLocations() {
+		 **/
+		public Locations getLocations(){
 			return new Locations() {
 
 				@Override
@@ -180,7 +171,7 @@ public class VehicleRoutingProblem {
 		 * @return builder
 		 * @see VehicleRoutingTransportCosts
 		 */
-        public Builder setRoutingCost(VehicleRoutingTransportCosts costs) {
+		public Builder setRoutingCost(VehicleRoutingTransportCosts costs){
 			this.transportCosts = costs;
 			return this;
 		}
@@ -188,20 +179,20 @@ public class VehicleRoutingProblem {
 
 		/**
 		 * Sets the type of fleetSize.
-         * <p/>
+		 *
 		 * <p>FleetSize is either FleetSize.INFINITE or FleetSize.FINITE. By default it is FleetSize.INFINITE.
 		 *
 		 * @param fleetSize the fleet size used in this problem. it can either be FleetSize.INFINITE or FleetSize.FINITE
 		 * @return this builder
 		 */
-        public Builder setFleetSize(FleetSize fleetSize) {
+		public Builder setFleetSize(FleetSize fleetSize){
 			this.fleetSize = fleetSize;
 			return this;
 		}
 
 		/**
 		 * Adds a job which is either a service or a shipment.
-         * <p/>
+		 *
 		 * <p>Note that job.getId() must be unique, i.e. no job (either it is a shipment or a service) is allowed to have an already allocated id.
 		 *
 		 * @param job job to be added
@@ -211,13 +202,13 @@ public class VehicleRoutingProblem {
 		 */
         @Deprecated
 		public Builder addJob(Job job) {
-            if (!(job instanceof AbstractJob)) throw new IllegalArgumentException("job must be of type AbstractJob");
+            if(!(job instanceof AbstractJob)) throw new IllegalArgumentException("job must be of type AbstractJob");
-            return addJob((AbstractJob) job);
+            return addJob((AbstractJob)job);
 		}
 
         /**
          * Adds a job which is either a service or a shipment.
-         * <p/>
+         *
          * <p>Note that job.getId() must be unique, i.e. no job (either it is a shipment or a service) is allowed to have an already allocated id.
          *
          * @param job job to be added
@@ -225,10 +216,8 @@ public class VehicleRoutingProblem {
          * @throws IllegalStateException if job is neither a shipment nor a service, or jobId has already been added.
          */
         public Builder addJob(AbstractJob job) {
-            if (tentativeJobs.containsKey(job.getId()))
+            if(tentativeJobs.containsKey(job.getId())) throw new IllegalStateException("jobList already contains a job with id " + job.getId() + ". make sure you use unique ids for your jobs (i.e. service and shipments)");
-                throw new IllegalStateException("jobList already contains a job with id " + job.getId() + ". make sure you use unique ids for your jobs (i.e. service and shipments)");
+            if(!(job instanceof Service || job instanceof Shipment)) throw new IllegalStateException("job must be either a service or a shipment");
-            if (!(job instanceof Service || job instanceof Shipment))
-                throw new IllegalStateException("job must be either a service or a shipment");
             job.setIndex(jobIndexCounter);
             incJobIndexCounter();
             tentativeJobs.put(job.getId(), job);
@@ -237,25 +226,27 @@ public class VehicleRoutingProblem {
         }
 
 		private void addLocationToTentativeLocations(Job job) {
-            if (job instanceof Service) {
+			if(job instanceof Service) {
-                tentative_coordinates.put(((Service) job).getLocation().getId(), ((Service) job).getLocation().getCoordinate());
+				tentative_coordinates.put(((Service)job).getLocation().getId(), ((Service)job).getLocation().getCoordinate());
-            } else if (job instanceof Shipment) {
+			}
-                Shipment shipment = (Shipment) job;
+			else if(job instanceof Shipment){
+				Shipment shipment = (Shipment)job;
 				tentative_coordinates.put(shipment.getPickupLocation().getId(), shipment.getPickupLocation().getCoordinate());
 				tentative_coordinates.put(shipment.getDeliveryLocation().getId(), shipment.getDeliveryLocation().getCoordinate());
 			}
 		}
 
-        private void addJobToFinalJobMapAndCreateActivities(Job job) {
+		private void addJobToFinalJobMapAndCreateActivities(Job job){
-            if (job instanceof Service) {
+            if(job instanceof Service) {
                 Service service = (Service) job;
 				addService(service);
-            } else if (job instanceof Shipment) {
+			}
-                Shipment shipment = (Shipment) job;
+			else if(job instanceof Shipment){
+				Shipment shipment = (Shipment)job;
                 addShipment(shipment);
 			}
             List<AbstractActivity> jobActs = jobActivityFactory.createActivities(job);
-            for (AbstractActivity act : jobActs) {
+            for(AbstractActivity act : jobActs){
                 act.setIndex(activityIndexCounter);
                 incActivityIndexCounter();
             }
@@ -269,13 +260,13 @@ public class VehicleRoutingProblem {
          * @param route initial route
          * @return the builder
          */
-        public Builder addInitialVehicleRoute(VehicleRoute route) {
+        public Builder addInitialVehicleRoute(VehicleRoute route){
-            addVehicle((AbstractVehicle) route.getVehicle());
+			addVehicle((AbstractVehicle)route.getVehicle());
-            for (TourActivity act : route.getActivities()) {
+            for(TourActivity act : route.getActivities()){
                 AbstractActivity abstractAct = (AbstractActivity) act;
                 abstractAct.setIndex(activityIndexCounter);
                 incActivityIndexCounter();
-                if (act instanceof TourActivity.JobActivity) {
+                if(act instanceof TourActivity.JobActivity) {
                     Job job = ((TourActivity.JobActivity) act).getJob();
                     jobsInInitialRoutes.add(job.getId());
                     registerLocation(job);
@@ -287,8 +278,7 @@ public class VehicleRoutingProblem {
 		}
 
         private void registerLocation(Job job) {
-            if (job instanceof Service)
+            if (job instanceof Service) tentative_coordinates.put(((Service) job).getLocation().getId(), ((Service) job).getLocation().getCoordinate());
-                tentative_coordinates.put(((Service) job).getLocation().getId(), ((Service) job).getLocation().getCoordinate());
             if (job instanceof Shipment) {
                 Shipment shipment = (Shipment) job;
                 tentative_coordinates.put(shipment.getPickupLocation().getId(), shipment.getPickupLocation().getCoordinate());
@@ -297,11 +287,11 @@ public class VehicleRoutingProblem {
         }
 
         private void registerJobAndActivity(AbstractActivity abstractAct, Job job) {
-            if (activityMap.containsKey(job)) activityMap.get(job).add(abstractAct);
+            if(activityMap.containsKey(job)) activityMap.get(job).add(abstractAct);
-            else {
+            else{
                 List<AbstractActivity> actList = new ArrayList<AbstractActivity>();
                 actList.add(abstractAct);
-                activityMap.put(job, actList);
+                activityMap.put(job,actList);
             }
         }
 
@@ -311,61 +301,61 @@ public class VehicleRoutingProblem {
          * @param routes initial routes
          * @return the builder
          */
-        public Builder addInitialVehicleRoutes(Collection<VehicleRoute> routes) {
+        public Builder addInitialVehicleRoutes(Collection<VehicleRoute> routes){
-            for (VehicleRoute r : routes) {
+			for(VehicleRoute r : routes){
 				addInitialVehicleRoute(r);
 			}
 			return this;
 		}
 
 		private void addShipment(Shipment job) {
-            if (jobs.containsKey(job.getId())) {
+			if(jobs.containsKey(job.getId())){ logger.warn("job " + job + " already in job list. overrides existing job."); }
-                logger.warn("job {} already in job list. overrides existing job.", job);
-            }
 			tentative_coordinates.put(job.getPickupLocation().getId(), job.getPickupLocation().getCoordinate());
 			tentative_coordinates.put(job.getDeliveryLocation().getId(), job.getDeliveryLocation().getCoordinate());
-            jobs.put(job.getId(), job);
+			jobs.put(job.getId(),job);
 		}
 
 		/**
 		 * Adds a vehicle.
 		 *
+		 *
 		 * @param vehicle vehicle to be added
 		 * @return this builder
          * @deprecated use addVehicle(AbstractVehicle vehicle) instead
 		 */
         @Deprecated
 		public Builder addVehicle(Vehicle vehicle) {
-            if (!(vehicle instanceof AbstractVehicle))
+            if(!(vehicle instanceof AbstractVehicle)) throw new IllegalStateException("vehicle must be an AbstractVehicle");
-                throw new IllegalStateException("vehicle must be an AbstractVehicle");
+            return addVehicle((AbstractVehicle)vehicle);
-            return addVehicle((AbstractVehicle) vehicle);
 		}
 
         /**
          * Adds a vehicle.
          *
+         *
          * @param vehicle vehicle to be added
          * @return this builder
          */
         public Builder addVehicle(AbstractVehicle vehicle) {
-            if (!uniqueVehicles.contains(vehicle)) {
+            if(!uniqueVehicles.contains(vehicle)){
                 vehicle.setIndex(vehicleIndexCounter);
                 incVehicleIndexCounter();
             }
-            if (typeKeyIndices.containsKey(vehicle.getVehicleTypeIdentifier())) {
+            if(typeKeyIndices.containsKey(vehicle.getVehicleTypeIdentifier())){
                 vehicle.getVehicleTypeIdentifier().setIndex(typeKeyIndices.get(vehicle.getVehicleTypeIdentifier()));
-            } else {
+            }
+            else {
                 vehicle.getVehicleTypeIdentifier().setIndex(vehicleTypeIdIndexCounter);
-                typeKeyIndices.put(vehicle.getVehicleTypeIdentifier(), vehicleTypeIdIndexCounter);
+                typeKeyIndices.put(vehicle.getVehicleTypeIdentifier(),vehicleTypeIdIndexCounter);
                 incVehicleTypeIdIndexCounter();
             }
             uniqueVehicles.add(vehicle);
-            if (!vehicleTypes.contains(vehicle.getType())) {
+            if(!vehicleTypes.contains(vehicle.getType())){
                 vehicleTypes.add(vehicle.getType());
             }
             String startLocationId = vehicle.getStartLocation().getId();
             tentative_coordinates.put(startLocationId, vehicle.getStartLocation().getCoordinate());
-            if (!vehicle.getEndLocation().getId().equals(startLocationId)) {
+            if(!vehicle.getEndLocation().getId().equals(startLocationId)){
                 tentative_coordinates.put(vehicle.getEndLocation().getId(), vehicle.getEndLocation().getCoordinate());
             }
             return this;
@@ -377,30 +367,30 @@ public class VehicleRoutingProblem {
 
         /**
 		 * Sets the activity-costs.
-         * <p/>
+		 *
 		 * <p>By default it is set to zero.
 		 *
 		 * @param activityCosts activity costs of the problem
 		 * @return this builder
 		 * @see VehicleRoutingActivityCosts
 		 */
-        public Builder setActivityCosts(VehicleRoutingActivityCosts activityCosts) {
+		public Builder setActivityCosts(VehicleRoutingActivityCosts activityCosts){
 			this.activityCosts = activityCosts;
 			return this;
 		}
 
 		/**
 		 * Builds the {@link VehicleRoutingProblem}.
-         * <p/>
+		 *
 		 * <p>If {@link VehicleRoutingTransportCosts} are not set, {@link CrowFlyCosts} is used.
 		 *
 		 * @return {@link VehicleRoutingProblem}
 		 */
 		public VehicleRoutingProblem build() {
-            if (transportCosts == null) {
+			if(transportCosts == null){
 				transportCosts = new CrowFlyCosts(getLocations());
 			}
-            for (Job job : tentativeJobs.values())
+            for(Job job : tentativeJobs.values())
                 if (!jobsInInitialRoutes.contains(job.getId())) {
                     addJobToFinalJobMapAndCreateActivities(job);
                 }
@@ -421,7 +411,7 @@ public class VehicleRoutingProblem {
 		 */
 		@SuppressWarnings("deprecation")
         public Builder addAllJobs(Collection<? extends Job> jobs) {
-            for (Job j : jobs) {
+			for(Job j : jobs){
 				addJob(j);
 			}
 			return this;
@@ -435,7 +425,7 @@ public class VehicleRoutingProblem {
 		 */
 		@SuppressWarnings("deprecation")
         public Builder addAllVehicles(Collection<? extends Vehicle> vehicles) {
-            for (Vehicle v : vehicles) {
+			for(Vehicle v : vehicles){
 				addVehicle(v);
 			}
 			return this;
@@ -446,7 +436,7 @@ public class VehicleRoutingProblem {
 		 *
 		 * @return collection of vehicles
 		 */
-        public Collection<Vehicle> getAddedVehicles() {
+		public Collection<Vehicle> getAddedVehicles(){
 			return Collections.unmodifiableCollection(uniqueVehicles);
 		}
 
@@ -455,7 +445,7 @@ public class VehicleRoutingProblem {
 		 *
 		 * @return collection of vehicle-types
 		 */
-        public Collection<VehicleType> getAddedVehicleTypes() {
+		public Collection<VehicleType> getAddedVehicleTypes(){
 			return Collections.unmodifiableCollection(vehicleTypes);
 		}
 
@@ -464,7 +454,7 @@ public class VehicleRoutingProblem {
          *
          * @return collection of jobs
          */
-        public Collection<Job> getAddedJobs() {
+		public Collection<Job> getAddedJobs(){
 			return Collections.unmodifiableCollection(tentativeJobs.values());
 		}
 
@@ -478,12 +468,13 @@ public class VehicleRoutingProblem {
         }
 
 
-    }
+}
 
 	/**
 	 * Enum that characterizes the fleet-size.
 	 *
 	 * @author sschroeder
+	 *
 	 */
 	public static enum FleetSize {
 		FINITE, INFINITE
@@ -529,7 +520,7 @@ public class VehicleRoutingProblem {
 
 	private final Locations locations;
 
-    private Map<Job, List<AbstractActivity>> activityMap;
+    private Map<Job,List<AbstractActivity>> activityMap;
 
     private int nuActivities;
 
@@ -545,7 +536,7 @@ public class VehicleRoutingProblem {
 	private VehicleRoutingProblem(Builder builder) {
 		this.jobs = builder.jobs;
 		this.fleetSize = builder.fleetSize;
-        this.vehicles = builder.uniqueVehicles;
+		this.vehicles=builder.uniqueVehicles;
 		this.vehicleTypes = builder.vehicleTypes;
 		this.initialVehicleRoutes = builder.initialRoutes;
 		this.transportCosts = builder.transportCosts;
@@ -564,7 +555,7 @@ public class VehicleRoutingProblem {
 
 	/**
 	 * Returns type of fleetSize, either INFINITE or FINITE.
-     * <p/>
+	 *
 	 * <p>By default, it is INFINITE.
 	 *
 	 * @return either FleetSize.INFINITE or FleetSize.FINITE
@@ -587,9 +578,9 @@ public class VehicleRoutingProblem {
      *
      * @return copied collection of initial vehicle routes
      */
-    public Collection<VehicleRoute> getInitialVehicleRoutes() {
+	public Collection<VehicleRoute> getInitialVehicleRoutes(){
 		Collection<VehicleRoute> copiedInitialRoutes = new ArrayList<VehicleRoute>();
-        for (VehicleRoute route : initialVehicleRoutes) {
+        for(VehicleRoute route : initialVehicleRoutes){
             copiedInitialRoutes.add(VehicleRoute.copyOf(route));
         }
         return copiedInitialRoutes;
@@ -601,7 +592,7 @@ public class VehicleRoutingProblem {
 	 * @return unmodifiable collection of types
 	 * @see VehicleTypeImpl
 	 */
-    public Collection<VehicleType> getTypes() {
+	public Collection<VehicleType> getTypes(){
 		return Collections.unmodifiableCollection(vehicleTypes);
 	}
 
@@ -629,14 +620,14 @@ public class VehicleRoutingProblem {
 	/**
 	 * Returns activityCosts.
 	 */
-    public VehicleRoutingActivityCosts getActivityCosts() {
+	public VehicleRoutingActivityCosts getActivityCosts(){
 		return activityCosts;
 	}
 
     /**
      * @return returns all location, i.e. from vehicles and jobs.
      */
-    public Locations getLocations() {
+	public Locations getLocations(){
 		return locations;
 	}
 
@@ -644,21 +635,19 @@ public class VehicleRoutingProblem {
      * @param job for which the corresponding activities needs to be returned
      * @return associated activities
      */
-    public List<AbstractActivity> getActivities(Job job) {
+    public List<AbstractActivity> getActivities(Job job){
         return Collections.unmodifiableList(activityMap.get(job));
     }
 
     /**
      * @return total number of activities
      */
-    public int getNuActivities() {
+    public int getNuActivities(){ return nuActivities; }
-        return nuActivities;
-    }
 
     /**
      * @return factory that creates the activities associated to a job
      */
-    public JobActivityFactory getJobActivityFactory() {
+    public JobActivityFactory getJobActivityFactory(){
         return jobActivityFactory;
     }
 
@@ -666,9 +655,9 @@ public class VehicleRoutingProblem {
      * @param job for which the corresponding activities needs to be returned
      * @return a copy of the activities that are associated to the specified job
      */
-    public List<AbstractActivity> copyAndGetActivities(Job job) {
+    public List<AbstractActivity> copyAndGetActivities(Job job){
         List<AbstractActivity> acts = new ArrayList<AbstractActivity>();
-        if (activityMap.containsKey(job)) {
+        if(activityMap.containsKey(job)) {
             for (AbstractActivity act : activityMap.get(job)) acts.add((AbstractActivity) act.duplicate());
         }
         return acts;

jsprit-core/src/main/java/jsprit/core/problem/cost/WaitingTimeCosts.java

@@ -0,0 +1,20 @@
+package jsprit.core.problem.cost;
+
+import jsprit.core.problem.driver.Driver;
+import jsprit.core.problem.solution.route.activity.TourActivity;
+import jsprit.core.problem.vehicle.Vehicle;
+
+/**
+ * Created by schroeder on 23/07/15.
+ */
+public class WaitingTimeCosts implements VehicleRoutingActivityCosts {
+
+    @Override
+    public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) {
+        if(vehicle != null){
+            return vehicle.getType().getVehicleCostParams().perWaitingTimeUnit * Math.max(0.,tourAct.getTheoreticalEarliestOperationStartTime()-arrivalTime);
+        }
+        return 0;
+    }
+
+}

jsprit-core/src/main/java/jsprit/core/problem/vehicle/InfiniteVehicles.java

@@ -25,17 +25,19 @@ import java.util.HashMap;
 import java.util.Map;
 
 
-class InfiniteVehicles implements VehicleFleetManager {
+
+
+class InfiniteVehicles implements VehicleFleetManager{
 
 	private static Logger logger = LogManager.getLogger(InfiniteVehicles.class);
 
-    private Map<VehicleTypeKey, Vehicle> types = new HashMap<VehicleTypeKey, Vehicle>();
+	private Map<VehicleTypeKey,Vehicle> types = new HashMap<VehicleTypeKey, Vehicle>();
 
 //	private List<VehicleTypeKey> sortedTypes = new ArrayList<VehicleTypeKey>();
 
-    public InfiniteVehicles(Collection<Vehicle> vehicles) {
+	public InfiniteVehicles(Collection<Vehicle> vehicles){
 		extractTypes(vehicles);
-        logger.debug("initialise {}", this);
+		logger.debug("initialise " + this);
 	}
 
 	@Override
@@ -44,9 +46,9 @@ class InfiniteVehicles implements VehicleFleetManager {
 	}
 
 	private void extractTypes(Collection<Vehicle> vehicles) {
-        for (Vehicle v : vehicles) {
+		for(Vehicle v : vehicles){
-            VehicleTypeKey typeKey = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(), v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills());
+			VehicleTypeKey typeKey = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(),v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills(), v.isReturnToDepot());
-            types.put(typeKey, v);
+			types.put(typeKey,v);
 //			sortedTypes.add(typeKey);
 		}
 	}
@@ -81,9 +83,9 @@ class InfiniteVehicles implements VehicleFleetManager {
 	@Override
 	public Collection<Vehicle> getAvailableVehicles(Vehicle withoutThisType) {
 		Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
-        VehicleTypeKey thisKey = new VehicleTypeKey(withoutThisType.getType().getTypeId(), withoutThisType.getStartLocation().getId(), withoutThisType.getEndLocation().getId(), withoutThisType.getEarliestDeparture(), withoutThisType.getLatestArrival(), withoutThisType.getSkills());
+		VehicleTypeKey thisKey = new VehicleTypeKey(withoutThisType.getType().getTypeId(), withoutThisType.getStartLocation().getId(), withoutThisType.getEndLocation().getId(), withoutThisType.getEarliestDeparture(), withoutThisType.getLatestArrival(), withoutThisType.getSkills(), withoutThisType.isReturnToDepot());
-        for (VehicleTypeKey key : types.keySet()) {
+		for(VehicleTypeKey key : types.keySet()){
-            if (!key.equals(thisKey)) {
+			if(!key.equals(thisKey)){
 				vehicles.add(types.get(key));
 			}
 		}

jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java

@@ -70,4 +70,5 @@ public interface Vehicle extends HasId, HasIndex {
     public abstract VehicleTypeKey getVehicleTypeIdentifier();
 
     public abstract Skills getSkills();
+
 }

jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleFleetManagerImpl.java

@@ -25,7 +25,7 @@ import java.util.*;
 
 class VehicleFleetManagerImpl implements VehicleFleetManager {
 
-    public VehicleFleetManagerImpl newInstance(Collection<Vehicle> vehicles) {
+	public VehicleFleetManagerImpl newInstance(Collection<Vehicle> vehicles){
 		return new VehicleFleetManagerImpl(vehicles);
 	}
 
@@ -38,14 +38,14 @@ class VehicleFleetManagerImpl implements VehicleFleetManager {
 			vehicleList = new ArrayList<Vehicle>();
 		}
 
-        void add(Vehicle vehicle) {
+		void add(Vehicle vehicle){
-            if (vehicleList.contains(vehicle)) {
+			if(vehicleList.contains(vehicle)){
 				throw new IllegalStateException("cannot add vehicle twice " + vehicle.getId());
 			}
 			vehicleList.add(vehicle);
 		}
 
-        void remove(Vehicle vehicle) {
+		void remove(Vehicle vehicle){
 			vehicleList.remove(vehicle);
 		}
 
@@ -66,9 +66,9 @@ class VehicleFleetManagerImpl implements VehicleFleetManager {
 
 	private Set<Vehicle> lockedVehicles;
 
-    private Map<VehicleTypeKey, TypeContainer> typeMapOfAvailableVehicles;
+	private Map<VehicleTypeKey,TypeContainer> typeMapOfAvailableVehicles;
 
-    private Map<VehicleTypeKey, Vehicle> penaltyVehicles = new HashMap<VehicleTypeKey, Vehicle>();
+	private Map<VehicleTypeKey,Vehicle> penaltyVehicles = new HashMap<VehicleTypeKey, Vehicle>();
 
 
 	public VehicleFleetManagerImpl(Collection<Vehicle> vehicles) {
@@ -76,7 +76,7 @@ class VehicleFleetManagerImpl implements VehicleFleetManager {
 		this.vehicles = vehicles;
 		this.lockedVehicles = new HashSet<Vehicle>();
 		makeMap();
-        logger.debug("initialise {}", this);
+		logger.debug("initialise " + this);
 	}
 
 	@Override
@@ -87,26 +87,26 @@ class VehicleFleetManagerImpl implements VehicleFleetManager {
 	private void makeMap() {
 		typeMapOfAvailableVehicles = new HashMap<VehicleTypeKey, TypeContainer>();
 		penaltyVehicles = new HashMap<VehicleTypeKey, Vehicle>();
-        for (Vehicle v : vehicles) {
+		for(Vehicle v : vehicles){
 			addVehicle(v);
 		}
 	}
 
 	private void addVehicle(Vehicle v) {
-        if (v.getType() == null) {
+		if(v.getType() == null){
 			throw new IllegalStateException("vehicle needs type");
 		}
-        VehicleTypeKey typeKey = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(), v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills());
+		VehicleTypeKey typeKey = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(), v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills(),v.isReturnToDepot() );
-        if (!typeMapOfAvailableVehicles.containsKey(typeKey)) {
+		if(!typeMapOfAvailableVehicles.containsKey(typeKey)){
 			typeMapOfAvailableVehicles.put(typeKey, new TypeContainer());
 		}
 		typeMapOfAvailableVehicles.get(typeKey).add(v);
 
 	}
 
-    private void removeVehicle(Vehicle v) {
+	private void removeVehicle(Vehicle v){
-        VehicleTypeKey key = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(), v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills());
+		VehicleTypeKey key = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(), v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills(),v.isReturnToDepot() );
-        if (typeMapOfAvailableVehicles.containsKey(key)) {
+		if(typeMapOfAvailableVehicles.containsKey(key)){
 			typeMapOfAvailableVehicles.get(key).remove(v);
 		}
 	}
@@ -114,18 +114,19 @@ class VehicleFleetManagerImpl implements VehicleFleetManager {
 
 	/**
 	 * Returns a collection of available vehicles.
-     * <p/>
+	 *
-     * <p>If there is no vehicle with a certain type and location anymore, it looks up whether a penalty vehicle has been specified with
+	 *<p>If there is no vehicle with a certain type and location anymore, it looks up whether a penalty vehicle has been specified with
 	 * this type and location. If so, it returns this penalty vehicle. If not, no vehicle with this type and location is returned.
 	 */
 	@Override
 	public Collection<Vehicle> getAvailableVehicles() {
 		List<Vehicle> vehicles = new ArrayList<Vehicle>();
-        for (VehicleTypeKey key : typeMapOfAvailableVehicles.keySet()) {
+		for(VehicleTypeKey key : typeMapOfAvailableVehicles.keySet()){
-            if (!typeMapOfAvailableVehicles.get(key).isEmpty()) {
+			if(!typeMapOfAvailableVehicles.get(key).isEmpty()){
 				vehicles.add(typeMapOfAvailableVehicles.get(key).getVehicle());
-            } else {
+			}
-                if (penaltyVehicles.containsKey(key)) {
+			else{
+				if(penaltyVehicles.containsKey(key)){
 					vehicles.add(penaltyVehicles.get(key));
 				}
 			}
@@ -136,13 +137,14 @@ class VehicleFleetManagerImpl implements VehicleFleetManager {
 	@Override
 	public Collection<Vehicle> getAvailableVehicles(Vehicle withoutThisType) {
 		List<Vehicle> vehicles = new ArrayList<Vehicle>();
-        VehicleTypeKey thisKey = new VehicleTypeKey(withoutThisType.getType().getTypeId(), withoutThisType.getStartLocation().getId(), withoutThisType.getEndLocation().getId(), withoutThisType.getEarliestDeparture(), withoutThisType.getLatestArrival(), withoutThisType.getSkills());
+		VehicleTypeKey thisKey = new VehicleTypeKey(withoutThisType.getType().getTypeId(), withoutThisType.getStartLocation().getId(), withoutThisType.getEndLocation().getId(), withoutThisType.getEarliestDeparture(), withoutThisType.getLatestArrival(), withoutThisType.getSkills(),withoutThisType.isReturnToDepot() );
-        for (VehicleTypeKey key : typeMapOfAvailableVehicles.keySet()) {
+		for(VehicleTypeKey key : typeMapOfAvailableVehicles.keySet()){
-            if (key.equals(thisKey)) continue;
+			if(key.equals(thisKey)) continue;
-            if (!typeMapOfAvailableVehicles.get(key).isEmpty()) {
+			if(!typeMapOfAvailableVehicles.get(key).isEmpty()){
 				vehicles.add(typeMapOfAvailableVehicles.get(key).getVehicle());
-            } else {
+			}
-                if (penaltyVehicles.containsKey(key)) {
+			else{
+				if(penaltyVehicles.containsKey(key)){
 					vehicles.add(penaltyVehicles.get(key));
 				}
 			}
@@ -154,13 +156,13 @@ class VehicleFleetManagerImpl implements VehicleFleetManager {
 	 * @see org.matsim.contrib.freight.vrp.basics.VehicleFleetManager#lock(org.matsim.contrib.freight.vrp.basics.Vehicle)
 	 */
 	@Override
-    public void lock(Vehicle vehicle) {
+	public void lock(Vehicle vehicle){
-        if (vehicles.isEmpty() || vehicle instanceof NoVehicle) {
+		if(vehicles.isEmpty() || vehicle instanceof NoVehicle){
 			return;
 		}
 		boolean locked = lockedVehicles.add(vehicle);
 		removeVehicle(vehicle);
-        if (!locked) {
+		if(!locked){
 			throw new IllegalStateException("cannot lock vehicle twice " + vehicle.getId());
 		}
 	}
@@ -169,11 +171,11 @@ class VehicleFleetManagerImpl implements VehicleFleetManager {
 	 * @see org.matsim.contrib.freight.vrp.basics.VehicleFleetManager#unlock(org.matsim.contrib.freight.vrp.basics.Vehicle)
 	 */
 	@Override
-    public void unlock(Vehicle vehicle) {
+	public void unlock(Vehicle vehicle){
-        if (vehicles.isEmpty() || vehicle instanceof NoVehicle) {
+		if(vehicles.isEmpty() || vehicle instanceof NoVehicle){
 			return;
 		}
-        if (vehicle == null) return;
+		if(vehicle == null) return;
 		lockedVehicles.remove(vehicle);
 		addVehicle(vehicle);
 	}
@@ -192,16 +194,16 @@ class VehicleFleetManagerImpl implements VehicleFleetManager {
 	@Override
 	public void unlockAll() {
 		Collection<Vehicle> locked = new ArrayList<Vehicle>(lockedVehicles);
-        for (Vehicle v : locked) {
+		for(Vehicle v : locked){
 			unlock(v);
 		}
-        if (!lockedVehicles.isEmpty()) {
+		if(!lockedVehicles.isEmpty()){
 			throw new IllegalStateException("no vehicle must be locked");
 		}
 	}
 
 	@Deprecated
-    public int sizeOfLockedVehicles() {
+	public int sizeOfLockedVehicles(){
 		return lockedVehicles.size();
 	}
 

jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java

@@ -23,13 +23,17 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 
+
 /**
  * Implementation of {@link Vehicle}.
  *
  * @author stefan schroeder
+ *
  */
 
-public class VehicleImpl extends AbstractVehicle {
+public class VehicleImpl extends AbstractVehicle{
+
+
 
 
     /**
@@ -37,6 +41,7 @@ public class VehicleImpl extends AbstractVehicle {
 	 * (to avoid null).
 	 *
 	 * @author schroeder
+	 *
 	 */
 	public static class NoVehicle extends AbstractVehicle {
 
@@ -90,12 +95,13 @@ public class VehicleImpl extends AbstractVehicle {
 
 	/**
 	 * Builder that builds the vehicle.
-     * <p/>
+	 *
 	 * <p>By default, earliestDepartureTime is 0.0, latestDepartureTime is Double.MAX_VALUE,
 	 * it returns to the depot and its {@link VehicleType} is the DefaultType with typeId equal to 'default'
 	 * and a capacity of 0.
 	 *
 	 * @author stefan
+	 *
 	 */
 	public static class Builder {
 
@@ -128,44 +134,43 @@ public class VehicleImpl extends AbstractVehicle {
 		 * Sets the {@link VehicleType}.<br>
 		 *
 		 * @param type the type to be set
-         * @return this builder
 		 * @throws IllegalStateException if type is null
+		 * @return this builder
 		 */
-        public Builder setType(VehicleType type) {
+		public Builder setType(VehicleType type){
-            if (type == null) throw new IllegalStateException("type cannot be null.");
+			if(type==null) throw new IllegalStateException("type cannot be null.");
 			this.type = type;
 			return this;
 		}
 
 		/**
 		 * Sets the flag whether the vehicle must return to depot or not.
-         * <p/>
+		 *
 		 * <p>If returnToDepot is true, the vehicle must return to specified end-location. If you
 		 * omit specifying the end-location, vehicle returns to start-location (that must to be set). If
 		 * you specify it, it returns to specified end-location.
-         * <p/>
+		 *
 		 * <p>If returnToDepot is false, the end-location of the vehicle is endogenous.
 		 *
 		 * @param returnToDepot true if vehicle need to return to depot, otherwise false
 		 * @return this builder
 		 */
-        public Builder setReturnToDepot(boolean returnToDepot) {
+		public Builder setReturnToDepot(boolean returnToDepot){
 			this.returnToDepot = returnToDepot;
 			return this;
 		}
 
         /**
          * Sets start location.
-         *
          * @param startLocation start location
          * @return start location
          */
-        public Builder setStartLocation(Location startLocation) {
+        public Builder setStartLocation(Location startLocation){
             this.startLocation = startLocation;
             return this;
         }
 
-        public Builder setEndLocation(Location endLocation) {
+        public Builder setEndLocation(Location endLocation){
             this.endLocation = endLocation;
             return this;
         }
@@ -176,7 +181,7 @@ public class VehicleImpl extends AbstractVehicle {
 		 * @param earliest_startTime the earliest start time / departure time of the vehicle at its start location
 		 * @return this builder
 		 */
-        public Builder setEarliestStart(double earliest_startTime) {
+		public Builder setEarliestStart(double earliest_startTime){
 			this.earliestStart = earliest_startTime;
 			return this;
 		}
@@ -187,22 +192,22 @@ public class VehicleImpl extends AbstractVehicle {
 		 * @param latest_arrTime the latest arrival time of the vehicle at its end location
 		 * @return this builder
 		 */
-        public Builder setLatestArrival(double latest_arrTime) {
+		public Builder setLatestArrival(double latest_arrTime){
 			this.latestArrival = latest_arrTime;
 			return this;
 		}
 
-        public Builder addSkill(String skill) {
+        public Builder addSkill(String skill){
             skillBuilder.addSkill(skill);
             return this;
         }
 
 		/**
 		 * Builds and returns the vehicle.
-         * <p/>
+		 *
 		 * <p>if {@link VehicleType} is not set, default vehicle-type is set with id="default" and
 		 * capacity=0
-         * <p/>
+		 *
 		 * <p>if startLocationId || locationId is null (=> startLocationCoordinate || locationCoordinate must be set) then startLocationId=startLocationCoordinate.toString()
 		 * and locationId=locationCoordinate.toString() [coord.toString() --> [x=x_val][y=y_val])
 		 * <p>if endLocationId is null and endLocationCoordinate is set then endLocationId=endLocationCoordinate.toString()
@@ -213,16 +218,15 @@ public class VehicleImpl extends AbstractVehicle {
 		 * @throws IllegalStateException if both locationId and locationCoord is not set or (endLocationCoord!=null AND returnToDepot=false)
 		 * or (endLocationId!=null AND returnToDepot=false)
 		 */
-        public VehicleImpl build() {
+		public VehicleImpl build(){
-            if (startLocation != null && endLocation != null) {
+            if(startLocation != null && endLocation != null){
-                if (!startLocation.getId().equals(endLocation.getId()) && !returnToDepot)
+                if( !startLocation.getId().equals(endLocation.getId()) && !returnToDepot) throw new IllegalStateException("this must not be. you specified both endLocationId and open-routes. this is contradictory. <br>" +
-                    throw new IllegalStateException("this must not be. you specified both endLocationId and open-routes. this is contradictory. <br>" +
                         "if you set endLocation, returnToDepot must be true. if returnToDepot is false, endLocationCoord must not be specified.");
             }
             if (startLocation != null && endLocation == null) {
                 endLocation = startLocation;
             }
-            if (startLocation == null && endLocation == null) {
+            if(startLocation == null && endLocation == null) {
 				throw new IllegalStateException("vehicle requires startLocation. but neither locationId nor locationCoord nor startLocationId nor startLocationCoord has been set");
 			}
             skills = skillBuilder.build();
@@ -235,9 +239,7 @@ public class VehicleImpl extends AbstractVehicle {
 		 * @param vehicleId the id of the vehicle which must be a unique identifier among all vehicles
 		 * @return vehicle builder
 		 */
-        public static Builder newInstance(String vehicleId) {
+		public static Builder newInstance(String vehicleId){ return new Builder(vehicleId); }
-            return new Builder(vehicleId);
-        }
 
         public Builder addSkills(Skills skills) {
             this.skillBuilder.addAllSkills(skills.values());
@@ -247,12 +249,12 @@ public class VehicleImpl extends AbstractVehicle {
 
 	/**
 	 * Returns empty/noVehicle which is a vehicle having no capacity, no type and no reasonable id.
-     * <p/>
+	 *
 	 * <p>NoVehicle has id="noVehicle" and extends {@link VehicleImpl}
 	 *
 	 * @return emptyVehicle
 	 */
-    public static NoVehicle createNoVehicle() {
+	public static NoVehicle createNoVehicle(){
 		return new NoVehicle();
 	}
 
@@ -272,7 +274,7 @@ public class VehicleImpl extends AbstractVehicle {
 
     private final Location startLocation;
 
-    private VehicleImpl(Builder builder) {
+	private VehicleImpl(Builder builder){
 		id = builder.id;
 		type = builder.type;
 		earliestDeparture = builder.earliestStart;
@@ -281,22 +283,22 @@ public class VehicleImpl extends AbstractVehicle {
 	    skills = builder.skills;
         endLocation = builder.endLocation;
         startLocation = builder.startLocation;
-        setVehicleIdentifier(new VehicleTypeKey(type.getTypeId(), startLocation.getId(), endLocation.getId(), earliestDeparture, latestArrival, skills));
+        setVehicleIdentifier(new VehicleTypeKey(type.getTypeId(),startLocation.getId(),endLocation.getId(),earliestDeparture,latestArrival,skills));
 	}
 
 	/**
 	 * Returns String with attributes of this vehicle
-     * <p/>
+	 *
 	 * <p>String has the following format [attr1=val1][attr2=val2]...[attrn=valn]
 	 */
 	@Override
 	public String toString() {
-        return "[id=" + id + "]" +
+		return "[id="+id+"]" +
-            "[type=" + type + "]" +
+                "[type="+type+"]" +
-            "[startLocation=" + startLocation + "]" +
+                "[startLocation="+startLocation+"]" +
-            "[endLocation=" + endLocation + "]" +
+                "[endLocation=" + endLocation+"]" +
                 "[isReturnToDepot=" + isReturnToDepot() + "]" +
-            "[skills=" + skills + "]";
+                "[skills="+ skills + "]";
 
 	}
 
@@ -377,4 +379,6 @@ public class VehicleImpl extends AbstractVehicle {
 	}
 
 
+
+
 }

jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeImpl.java

@@ -21,10 +21,11 @@ import jsprit.core.problem.Capacity;
 
 /**
  * Implementation of {@link VehicleType}.
- * <p/>
+ *
  * <p>Two vehicle-types are equal if they have the same typeId.
  *
  * @author schroeder
+ *
  */
 public class VehicleTypeImpl implements VehicleType {
 
@@ -32,27 +33,41 @@ public class VehicleTypeImpl implements VehicleType {
 	 * CostParameter consisting of fixed cost parameter, time-based cost parameter and distance-based cost parameter.
 	 *
 	 * @author schroeder
+	 *
 	 */
 	public static class VehicleCostParams {
 
-        public static VehicleTypeImpl.VehicleCostParams newInstance(double fix, double perTimeUnit, double perDistanceUnit) {
+		public static VehicleTypeImpl.VehicleCostParams newInstance(double fix, double perTimeUnit,double perDistanceUnit){
 			return new VehicleCostParams(fix, perTimeUnit, perDistanceUnit);
 		}
 
 		public final double fix;
+		@Deprecated
 		public final double perTimeUnit;
+		public final double perTransportTimeUnit;
 		public final double perDistanceUnit;
+		public final double perWaitingTimeUnit;
 
-        private VehicleCostParams(double fix, double perTimeUnit, double perDistanceUnit) {
+		private VehicleCostParams(double fix, double perTimeUnit,double perDistanceUnit) {
 			super();
 			this.fix = fix;
 			this.perTimeUnit = perTimeUnit;
+			this.perTransportTimeUnit = perTimeUnit;
 			this.perDistanceUnit = perDistanceUnit;
+			this.perWaitingTimeUnit = 0.;
+		}
+
+		public VehicleCostParams(double fix, double perTimeUnit, double perDistanceUnit, double perWaitingTimeUnit) {
+			this.fix = fix;
+			this.perTimeUnit = perTimeUnit;
+			this.perTransportTimeUnit = perTimeUnit;
+			this.perDistanceUnit = perDistanceUnit;
+			this.perWaitingTimeUnit = perWaitingTimeUnit;
 		}
 
 		@Override
 		public String toString() {
-            return "[fixed=" + fix + "][perTime=" + perTimeUnit + "][perDistance=" + perDistanceUnit + "]";
+			return "[fixed="+fix+"][perTime="+perTransportTimeUnit+"][perDistance="+perDistanceUnit+"][perWaitingTimeUnit="+perWaitingTimeUnit+"]";
 		}
 	}
 
@@ -60,11 +75,14 @@ public class VehicleTypeImpl implements VehicleType {
 	 * Builder that builds the vehicle-type.
 	 *
 	 * @author schroeder
+	 *
 	 */
-    public static class Builder {
+	public static class Builder{
+
+
 
 		public static VehicleTypeImpl.Builder newInstance(String id) {
-            if (id == null) throw new IllegalStateException();
+			if(id==null) throw new IllegalStateException();
 			return new Builder(id);
 		}
 
@@ -77,6 +95,7 @@ public class VehicleTypeImpl implements VehicleType {
 		private double fixedCost = 0.0;
 		private double perDistance = 1.0;
 		private double perTime = 0.0;
+		private double perWaitingTime = 0.0;
 
 		private String profile = "car";
 
@@ -97,15 +116,14 @@ public class VehicleTypeImpl implements VehicleType {
 		 * @return this builder
 		 * @throws IllegalStateException if velocity is smaller than zero
 		 */
-        public VehicleTypeImpl.Builder setMaxVelocity(double inMeterPerSeconds) {
+		public VehicleTypeImpl.Builder setMaxVelocity(double inMeterPerSeconds){
-            if (inMeterPerSeconds < 0.0) throw new IllegalStateException("velocity cannot be smaller than zero");
+			if(inMeterPerSeconds < 0.0) throw new IllegalStateException("velocity cannot be smaller than zero");
-            this.maxVelo = inMeterPerSeconds;
+			this.maxVelo = inMeterPerSeconds; return this;
-            return this;
 		}
 
 		/**
 		 * Sets the fixed costs of the vehicle-type.
-         * <p/>
+		 *
 		 * <p>by default it is 0.
 		 *
 		 * @param fixedCost
@@ -113,48 +131,82 @@ public class VehicleTypeImpl implements VehicleType {
 		 * @throws IllegalStateException if fixedCost is smaller than zero
 		 */
 		public VehicleTypeImpl.Builder setFixedCost(double fixedCost) {
-            if (fixedCost < 0.0) throw new IllegalStateException("fixed costs cannot be smaller than zero");
+			if(fixedCost < 0.0) throw new IllegalStateException("fixed costs cannot be smaller than zero");
 			this.fixedCost = fixedCost;
 			return this;
 		}
 
 		/**
 		 * Sets the cost per distance unit, for instance € per meter.
-         * <p/>
+		 *
 		 * <p>by default it is 1.0
 		 *
 		 * @param perDistance
 		 * @return this builder
 		 * @throws IllegalStateException if perDistance is smaller than zero
 		 */
-        public VehicleTypeImpl.Builder setCostPerDistance(double perDistance) {
+		public VehicleTypeImpl.Builder setCostPerDistance(double perDistance){
-            if (perDistance < 0.0) throw new IllegalStateException("cost per distance must not be smaller than zero");
+			if(perDistance < 0.0) throw new IllegalStateException("cost per distance must not be smaller than zero");
 			this.perDistance = perDistance;
 			return this;
 		}
 
 		/**
 		 * Sets cost per time unit, for instance € per second.
-         * <p/>
+		 *
 		 * <p>by default it is 0.0
 		 *
 		 * @param perTime
 		 * @return this builder
 		 * @throws IllegalStateException if costPerTime is smaller than zero
+		 * @deprecated use .setCostPerTransportTime(..) instead
 		 */
-        public VehicleTypeImpl.Builder setCostPerTime(double perTime) {
+		@Deprecated
-            if (perTime < 0.0) throw new IllegalStateException();
+		public VehicleTypeImpl.Builder setCostPerTime(double perTime){
+			if(perTime < 0.0) throw new IllegalStateException();
 			this.perTime = perTime;
 			return this;
 		}
 
+		/**
+		 * Sets cost per time unit, for instance € per second.
+		 *
+		 * <p>by default it is 0.0
+		 *
+		 * @param perTime
+		 * @return this builder
+		 * @throws IllegalStateException if costPerTime is smaller than zero
+		 *
+		 */
+		public VehicleTypeImpl.Builder setCostPerTransportTime(double perTime){
+			if(perTime < 0.0) throw new IllegalStateException();
+			this.perTime = perTime;
+			return this;
+		}
+
+		/**
+		 * Sets cost per waiting time unit, for instance € per second.
+		 *
+		 * <p>by default it is 0.0
+		 *
+		 * @param perWaitingTime
+		 * @return this builder
+		 * @throws IllegalStateException if costPerTime is smaller than zero
+		 *
+		 */
+		public VehicleTypeImpl.Builder setCostPerWaitingTime(double perWaitingTime){
+			if(perWaitingTime < 0.0) throw new IllegalStateException();
+			this.perWaitingTime = perWaitingTime;
+			return this;
+		}
+
 		/**
 		 * Builds the vehicle-type.
 		 *
 		 * @return VehicleTypeImpl
 		 */
-        public VehicleTypeImpl build() {
+		public VehicleTypeImpl build(){
-            if (capacityDimensions == null) {
+			if(capacityDimensions == null){
 				capacityDimensions = capacityBuilder.build();
 			}
 			return new VehicleTypeImpl(this);
@@ -170,19 +222,18 @@ public class VehicleTypeImpl implements VehicleType {
 		 * @throws IllegalStateException if capacity dimension is already set
 		 */
 		public Builder addCapacityDimension(int dimIndex, int dimVal) {
-            if (dimVal < 0) throw new IllegalArgumentException("capacity value cannot be negative");
+			if(dimVal<0) throw new IllegalArgumentException("capacity value cannot be negative");
-            if (capacityDimensions != null)
+			if(capacityDimensions != null) throw new IllegalStateException("either build your dimension with build your dimensions with " +
-                throw new IllegalStateException("either build your dimension with build your dimensions with " +
 					"addCapacityDimension(int dimIndex, int dimVal) or set the already built dimensions with .setCapacityDimensions(Capacity capacity)." +
 					"You used both methods.");
 			dimensionAdded = true;
-            capacityBuilder.addDimension(dimIndex, dimVal);
+			capacityBuilder.addDimension(dimIndex,dimVal);
 			return this;
 		}
 
 		/**
 		 * Sets capacity dimensions.
-         * <p/>
+		 *
 		 * <p>Note if you use this you cannot use <code>addCapacityDimension(int dimIndex, int dimVal)</code> anymore. Thus either build
 		 * your dimensions with <code>addCapacityDimension(int dimIndex, int dimVal)</code> or set the already built dimensions with
 		 * this method.
@@ -191,16 +242,15 @@ public class VehicleTypeImpl implements VehicleType {
 		 * @return this builder
 		 * @throws IllegalStateException if capacityDimension has already been added
 		 */
-        public Builder setCapacityDimensions(Capacity capacity) {
+		public Builder setCapacityDimensions(Capacity capacity){
-            if (dimensionAdded)
+			if(dimensionAdded) throw new IllegalStateException("either build your dimension with build your dimensions with " +
-                throw new IllegalStateException("either build your dimension with build your dimensions with " +
 					"addCapacityDimension(int dimIndex, int dimVal) or set the already built dimensions with .setCapacityDimensions(Capacity capacity)." +
 					"You used both methods.");
 			this.capacityDimensions = capacity;
 			return this;
 		}
 
-        public Builder setProfile(String profile) {
+		public Builder setProfile(String profile){
 			this.profile = profile;
 			return this;
 		}
@@ -252,11 +302,11 @@ public class VehicleTypeImpl implements VehicleType {
 	 *
 	 * @param builder
 	 */
-    private VehicleTypeImpl(VehicleTypeImpl.Builder builder) {
+	private VehicleTypeImpl(VehicleTypeImpl.Builder builder){
 		typeId = builder.id;
 		capacity = builder.capacity;
 		maxVelocity = builder.maxVelo;
-        vehicleCostParams = new VehicleCostParams(builder.fixedCost, builder.perTime, builder.perDistance);
+		vehicleCostParams = new VehicleCostParams(builder.fixedCost, builder.perTime, builder.perDistance, builder.perWaitingTime);
 		capacityDimensions = builder.capacityDimensions;
 		profile = builder.profile;
 	}
@@ -279,8 +329,8 @@ public class VehicleTypeImpl implements VehicleType {
 
 	@Override
 	public String toString() {
-        return "[typeId=" + typeId + "]" +
+        return "[typeId="+typeId+"]" +
-            "[capacity=" + capacityDimensions + "]" +
+                "[capacity="+capacityDimensions+"]" +
                 "[costs=" + vehicleCostParams + "]";
 	}
 
@@ -295,8 +345,6 @@ public class VehicleTypeImpl implements VehicleType {
 	}
 
 	@Override
-    public String getProfile() {
+	public String getProfile(){ return profile; }
-        return profile;
-    }
 
 }

jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeKey.java

@@ -23,12 +23,13 @@ import jsprit.core.problem.Skills;
 
 /**
  * Key to identify similar vehicles
- * <p/>
+ *
  * <p>Two vehicles are equal if they share the same type, the same start and end-location and the same earliestStart and latestStart.
  *
  * @author stefan
+ *
  */
-public class VehicleTypeKey extends AbstractVehicle.AbstractTypeKey {
+public class VehicleTypeKey extends AbstractVehicle.AbstractTypeKey{
 
 	public final String type;
 	public final String startLocationId;
@@ -36,8 +37,9 @@ public class VehicleTypeKey extends AbstractVehicle.AbstractTypeKey {
 	public final double earliestStart;
 	public final double latestEnd;
     public final Skills skills;
+    public final boolean returnToDepot;
 
-    public VehicleTypeKey(String typeId, String startLocationId, String endLocationId, double earliestStart, double latestEnd, Skills skills) {
+	public VehicleTypeKey(String typeId, String startLocationId, String endLocationId, double earliestStart, double latestEnd, Skills skills, boolean returnToDepot) {
 		super();
 		this.type = typeId;
 		this.startLocationId = startLocationId;
@@ -45,17 +47,19 @@ public class VehicleTypeKey extends AbstractVehicle.AbstractTypeKey {
 		this.earliestStart = earliestStart;
 		this.latestEnd = latestEnd;
         this.skills = skills;
+        this.returnToDepot=returnToDepot;
 	}
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
-        if (!(o instanceof VehicleTypeKey)) return false;
+        if (o == null || getClass() != o.getClass()) return false;
 
         VehicleTypeKey that = (VehicleTypeKey) o;
 
         if (Double.compare(that.earliestStart, earliestStart) != 0) return false;
         if (Double.compare(that.latestEnd, latestEnd) != 0) return false;
+        if (returnToDepot != that.returnToDepot) return false;
         if (!endLocationId.equals(that.endLocationId)) return false;
         if (!skills.equals(that.skills)) return false;
         if (!startLocationId.equals(that.startLocationId)) return false;
@@ -76,6 +80,7 @@ public class VehicleTypeKey extends AbstractVehicle.AbstractTypeKey {
         temp = Double.doubleToLongBits(latestEnd);
         result = 31 * result + (int) (temp ^ (temp >>> 32));
         result = 31 * result + skills.hashCode();
+        result = 31 * result + (returnToDepot ? 1 : 0);
         return result;
     }
 
@@ -88,4 +93,5 @@ public class VehicleTypeKey extends AbstractVehicle.AbstractTypeKey {
 	}
 
 
+
 }

jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java

@@ -0,0 +1,108 @@
+package jsprit.core.algorithm;
+
+import jsprit.core.algorithm.box.Jsprit;
+import jsprit.core.algorithm.state.StateManager;
+import jsprit.core.analysis.SolutionAnalyser;
+import jsprit.core.problem.Location;
+import jsprit.core.problem.VehicleRoutingProblem;
+import jsprit.core.problem.constraint.ConstraintManager;
+import jsprit.core.problem.cost.TransportDistance;
+import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
+import jsprit.core.problem.driver.Driver;
+import jsprit.core.problem.job.Service;
+import jsprit.core.problem.solution.SolutionCostCalculator;
+import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import jsprit.core.problem.solution.route.activity.TimeWindow;
+import jsprit.core.problem.solution.route.activity.TourActivity;
+import jsprit.core.problem.vehicle.Vehicle;
+import jsprit.core.problem.vehicle.VehicleImpl;
+import jsprit.core.util.CostFactory;
+import jsprit.core.util.Solutions;
+import junit.framework.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Created by schroeder on 22/07/15.
+ */
+public class VariableDepartureAndWaitingTime_IT {
+
+    static interface AlgorithmFactory {
+        VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vrp);
+    }
+
+    VehicleRoutingActivityCosts activityCosts;
+
+    AlgorithmFactory algorithmFactory;
+
+    @Before
+    public void doBefore(){
+        activityCosts = new VehicleRoutingActivityCosts() {
+
+            @Override
+            public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) {
+                return vehicle.getType().getVehicleCostParams().perWaitingTimeUnit * Math.max(0,tourAct.getTheoreticalEarliestOperationStartTime() - arrivalTime);
+            }
+
+        };
+        algorithmFactory = new AlgorithmFactory() {
+            @Override
+            public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) {
+                StateManager stateManager = new StateManager(vrp);
+                ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
+
+                return  Jsprit.Builder.newInstance(vrp)
+                        .addCoreStateAndConstraintStuff(true)
+                        .setStateAndConstraintManager(stateManager,constraintManager)
+                        .setObjectiveFunction(new SolutionCostCalculator() {
+                            @Override
+                            public double getCosts(VehicleRoutingProblemSolution solution) {
+                                SolutionAnalyser sa = new SolutionAnalyser(vrp, solution, new TransportDistance() {
+                                    @Override
+                                    public double getDistance(Location from, Location to) {
+                                        return vrp.getTransportCosts().getTransportCost(from, to, 0., null, null);
+                                    }
+                                });
+                                return sa.getWaitingTime() + sa.getDistance();
+                            }
+                        })
+                        .buildAlgorithm();
+            }
+        };
+    }
+
+    @Test
+    public void plainSetupShouldWork(){
+        VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(0,0)).build();
+        Service s1 = Service.Builder.newInstance("s1").setLocation(Location.newInstance(10,0)).build();
+        Service s2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance(20,0)).build();
+        VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance()
+                .addJob(s1).addJob(s2).addVehicle(v)
+                .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE)
+                .setRoutingCost(CostFactory.createManhattanCosts())
+                .setActivityCosts(activityCosts)
+                .build();
+        VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp);
+        VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions());
+        Assert.assertEquals(40.,solution.getCost());
+    }
+
+    @Test
+    public void withTimeWindowsShouldWork(){
+        VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(0,0)).build();
+        Service s1 = Service.Builder.newInstance("s1").setTimeWindow(TimeWindow.newInstance(1010,1100)).setLocation(Location.newInstance(10,0)).build();
+        Service s2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(1020,1100)).setLocation(Location.newInstance(20,0)).build();
+        final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance()
+                .addJob(s1).addJob(s2).addVehicle(v)
+                .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE)
+                .setRoutingCost(CostFactory.createManhattanCosts())
+                .setActivityCosts(activityCosts)
+                .build();
+        VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp);
+        VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions());
+        Assert.assertEquals(40.+1000.,solution.getCost());
+    }
+
+
+
+}

jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java

@@ -56,10 +56,10 @@ public class ServiceInsertionAndLoadConstraintsTest {
 
 	VehicleRoutingTransportCosts routingCosts;
 
-    VehicleRoutingActivityCosts activityCosts = new VehicleRoutingActivityCosts() {
+	VehicleRoutingActivityCosts activityCosts = new VehicleRoutingActivityCosts(){
 
 		@Override
-        public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) {
+		public double getActivityCost(TourActivity tourAct, double arrivalTime,Driver driver, Vehicle vehicle) {
 			return 0;
 		}
 
@@ -68,12 +68,12 @@ public class ServiceInsertionAndLoadConstraintsTest {
 	HardActivityConstraint hardActivityLevelConstraint = new HardActivityConstraint() {
 
 		@Override
-        public ConstraintsStatus fulfilled(JobInsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
+		public ConstraintsStatus fulfilled(JobInsertionContext iFacts, TourActivity prevAct,TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
 			return ConstraintsStatus.FULFILLED;
 		}
 	};
 
-    HardRouteConstraint hardRouteLevelConstraint = new HardRouteConstraint() {
+	HardRouteConstraint hardRouteLevelConstraint = new HardRouteConstraint(){
 
 		@Override
 		public boolean fulfilled(JobInsertionContext insertionContext) {
@@ -91,11 +91,11 @@ public class ServiceInsertionAndLoadConstraintsTest {
 	Vehicle vehicle;
 
 	@Before
-    public void doBefore() {
+	public void doBefore(){
 		routingCosts = CostFactory.createManhattanCosts();
 		VehicleType type = VehicleTypeImpl.Builder.newInstance("t").addCapacityDimension(0, 2).setCostPerDistance(1).build();
 		vehicle = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("0,0")).setType(type).build();
-        activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts);
+		activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts, mock(StateManager.class));
 		createInsertionCalculator(hardRouteLevelConstraint);
         vehicleRoutingProblem = mock(VehicleRoutingProblem.class);
     }

jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java

@@ -65,16 +65,16 @@ public class ShipmentInsertionCalculatorTest {
 
     VehicleRoutingProblem vehicleRoutingProblem;
 
-    VehicleRoutingActivityCosts activityCosts = new VehicleRoutingActivityCosts() {
+	VehicleRoutingActivityCosts activityCosts = new VehicleRoutingActivityCosts(){
 
 		@Override
-        public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) {
+		public double getActivityCost(TourActivity tourAct, double arrivalTime,Driver driver, Vehicle vehicle) {
 			return 0;
 		}
 
 	};
 
-    HardRouteConstraint hardRouteLevelConstraint = new HardRouteConstraint() {
+	HardRouteConstraint hardRouteLevelConstraint = new HardRouteConstraint(){
 
 		@Override
 		public boolean fulfilled(JobInsertionContext insertionContext) {
@@ -90,11 +90,11 @@ public class ShipmentInsertionCalculatorTest {
 	Vehicle vehicle;
 
 	@Before
-    public void doBefore() {
+	public void doBefore(){
 		routingCosts = CostFactory.createManhattanCosts();
 		VehicleType type = VehicleTypeImpl.Builder.newInstance("t").addCapacityDimension(0, 2).setCostPerDistance(1).build();
 		vehicle = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("0,0")).setType(type).build();
-        activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts);
+		activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts, mock(StateManager.class));
 		createInsertionCalculator(hardRouteLevelConstraint);
         vehicleRoutingProblem = mock(VehicleRoutingProblem.class);
 	}
@@ -106,7 +106,7 @@ public class ShipmentInsertionCalculatorTest {
 	}
 
 	@Test
-    public void whenCalculatingInsertionCostsOfShipment_itShouldReturnCorrectCostValue() {
+	public void whenCalculatingInsertionCostsOfShipment_itShouldReturnCorrectCostValue(){
 		Shipment shipment = Shipment.Builder.newInstance("s").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,10").build()).setDeliveryLocation(Location.newInstance("10,0")).build();
 		VehicleRoute route = VehicleRoute.emptyRoute();
         JobActivityFactory activityFactory = mock(JobActivityFactory.class);
@@ -116,16 +116,16 @@ public class ShipmentInsertionCalculatorTest {
         when(activityFactory.createActivities(shipment)).thenReturn(activities);
         insertionCalculator.setJobActivityFactory(activityFactory);
 		InsertionData iData = insertionCalculator.getInsertionData(route, shipment, vehicle, 0.0, null, Double.MAX_VALUE);
-        assertEquals(40.0, iData.getInsertionCost(), 0.05);
+		assertEquals(40.0,iData.getInsertionCost(),0.05);
 	}
 
 	@Test
-    public void whenCalculatingInsertionIntoExistingRoute_itShouldReturnCorrectCosts() {
+	public void whenCalculatingInsertionIntoExistingRoute_itShouldReturnCorrectCosts(){
 		Shipment shipment = Shipment.Builder.newInstance("s").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,10").build()).setDeliveryLocation(Location.newInstance("10,0")).build();
 		Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("10,10").build()).setDeliveryLocation(Location.newInstance("0,0")).build();
 		VehicleRoute route = VehicleRoute.emptyRoute();
 		when(vehicleRoutingProblem.copyAndGetActivities(shipment)).thenReturn(getTourActivities(shipment));
-        new Inserter(new InsertionListeners(), vehicleRoutingProblem).insertJob(shipment, new InsertionData(0, 0, 0, vehicle, null), route);
+        new Inserter(new InsertionListeners(), vehicleRoutingProblem).insertJob(shipment, new InsertionData(0,0,0,vehicle,null), route);
 
         JobActivityFactory activityFactory = mock(JobActivityFactory.class);
         List<AbstractActivity> activities = new ArrayList<AbstractActivity>();
@@ -135,9 +135,9 @@ public class ShipmentInsertionCalculatorTest {
         insertionCalculator.setJobActivityFactory(activityFactory);
 
 		InsertionData iData = insertionCalculator.getInsertionData(route, shipment2, vehicle, 0.0, null, Double.MAX_VALUE);
-        assertEquals(0.0, iData.getInsertionCost(), 0.05);
+		assertEquals(0.0,iData.getInsertionCost(),0.05);
-        assertEquals(1, iData.getPickupInsertionIndex());
+		assertEquals(1,iData.getPickupInsertionIndex());
-        assertEquals(2, iData.getDeliveryInsertionIndex());
+		assertEquals(2,iData.getDeliveryInsertionIndex());
 	}
 
     private List<AbstractActivity> getTourActivities(Shipment shipment) {
@@ -150,12 +150,12 @@ public class ShipmentInsertionCalculatorTest {
     }
 
     @Test
-    public void whenInsertingShipmentInRouteWithNotEnoughCapacity_itShouldReturnNoInsertion() {
+	public void whenInsertingShipmentInRouteWithNotEnoughCapacity_itShouldReturnNoInsertion(){
 		Shipment shipment = Shipment.Builder.newInstance("s").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,10").build()).setDeliveryLocation(Location.newInstance("10,0")).build();
 		Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("10,10").build()).setDeliveryLocation(Location.newInstance("0,0")).build();
 		VehicleRoute route = VehicleRoute.emptyRoute();
         when(vehicleRoutingProblem.copyAndGetActivities(shipment)).thenReturn(getTourActivities(shipment));
-        new Inserter(new InsertionListeners(), vehicleRoutingProblem).insertJob(shipment, new InsertionData(0, 0, 0, vehicle, null), route);
+		new Inserter(new InsertionListeners(), vehicleRoutingProblem).insertJob(shipment, new InsertionData(0,0,0,vehicle,null), route);
 		createInsertionCalculator(new HardRouteConstraint() {
 
 			@Override
@@ -173,13 +173,13 @@ public class ShipmentInsertionCalculatorTest {
         insertionCalculator.setJobActivityFactory(activityFactory);
 
         InsertionData iData = insertionCalculator.getInsertionData(route, shipment2, vehicle, 0.0, null, Double.MAX_VALUE);
-        assertEquals(InsertionData.createEmptyInsertionData(), iData);
+		assertEquals(InsertionData.createEmptyInsertionData(),iData);
 
 	}
 
 
 	@Test
-    public void whenInsertingThirdShipment_itShouldCalcCorrectVal() {
+	public void whenInsertingThirdShipment_itShouldCalcCorrectVal(){
 		Shipment shipment = Shipment.Builder.newInstance("s").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,10").build()).setDeliveryLocation(Location.newInstance("10,0")).build();
 		Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("10,10").build()).setDeliveryLocation(Location.newInstance("0,0")).build();
 		Shipment shipment3 = Shipment.Builder.newInstance("s3").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,0").build()).setDeliveryLocation(Location.newInstance("9,10")).build();
@@ -187,9 +187,9 @@ public class ShipmentInsertionCalculatorTest {
 		VehicleRoute route = VehicleRoute.emptyRoute();
         when(vehicleRoutingProblem.copyAndGetActivities(shipment)).thenReturn(getTourActivities(shipment));
         when(vehicleRoutingProblem.copyAndGetActivities(shipment2)).thenReturn(getTourActivities(shipment2));
-        Inserter inserter = new Inserter(new InsertionListeners(), vehicleRoutingProblem);
+		Inserter inserter = new Inserter(new InsertionListeners(),vehicleRoutingProblem );
-        inserter.insertJob(shipment, new InsertionData(0, 0, 0, vehicle, null), route);
+		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);
 
         JobActivityFactory activityFactory = mock(JobActivityFactory.class);
         List<AbstractActivity> activities = new ArrayList<AbstractActivity>();
@@ -199,13 +199,13 @@ public class ShipmentInsertionCalculatorTest {
         insertionCalculator.setJobActivityFactory(activityFactory);
 
 		InsertionData iData = insertionCalculator.getInsertionData(route, shipment3, vehicle, 0.0, null, Double.MAX_VALUE);
-        assertEquals(0.0, iData.getInsertionCost(), 0.05);
+		assertEquals(0.0,iData.getInsertionCost(),0.05);
-        assertEquals(0, iData.getPickupInsertionIndex());
+		assertEquals(0,iData.getPickupInsertionIndex());
-        assertEquals(1, iData.getDeliveryInsertionIndex());
+		assertEquals(1,iData.getDeliveryInsertionIndex());
 	}
 
 	@Test
-    public void whenInsertingThirdShipment_itShouldCalcCorrectVal2() {
+	public void whenInsertingThirdShipment_itShouldCalcCorrectVal2(){
 		Shipment shipment = Shipment.Builder.newInstance("s").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,10").build()).setDeliveryLocation(Location.newInstance("10,0")).build();
 		Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("10,10").build()).setDeliveryLocation(Location.newInstance("0,0")).build();
 		Shipment shipment3 = Shipment.Builder.newInstance("s3").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,0").build()).setDeliveryLocation(Location.newInstance("9,9")).build();
@@ -213,8 +213,8 @@ public class ShipmentInsertionCalculatorTest {
         when(vehicleRoutingProblem.copyAndGetActivities(shipment2)).thenReturn(getTourActivities(shipment2));
 		VehicleRoute route = VehicleRoute.emptyRoute();
 		Inserter inserter = new Inserter(new InsertionListeners(), vehicleRoutingProblem);
-        inserter.insertJob(shipment, new InsertionData(0, 0, 0, vehicle, null), route);
+		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);
 
         JobActivityFactory activityFactory = mock(JobActivityFactory.class);
         List<AbstractActivity> activities = new ArrayList<AbstractActivity>();
@@ -225,13 +225,13 @@ public class ShipmentInsertionCalculatorTest {
 
 
         InsertionData iData = insertionCalculator.getInsertionData(route, shipment3, vehicle, 0.0, null, Double.MAX_VALUE);
-        assertEquals(2.0, iData.getInsertionCost(), 0.05);
+		assertEquals(2.0,iData.getInsertionCost(),0.05);
-        assertEquals(0, iData.getPickupInsertionIndex());
+		assertEquals(0,iData.getPickupInsertionIndex());
-        assertEquals(1, iData.getDeliveryInsertionIndex());
+		assertEquals(1,iData.getDeliveryInsertionIndex());
 	}
 
 	@Test
-    public void whenInstertingShipmentWithLoadConstraintWhereCapIsNotSufficient_capConstraintsAreFulfilled() {
+	public void whenInstertingShipmentWithLoadConstraintWhereCapIsNotSufficient_capConstraintsAreFulfilled(){
 		Shipment shipment = Shipment.Builder.newInstance("s").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,10").build()).setDeliveryLocation(Location.newInstance("10,0")).build();
 		Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("10,10").build()).setDeliveryLocation(Location.newInstance("0,0")).build();
 		Shipment shipment3 = Shipment.Builder.newInstance("s3").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,0").build()).setDeliveryLocation(Location.newInstance("9,9")).build();
@@ -243,16 +243,16 @@ public class ShipmentInsertionCalculatorTest {
 		route.setVehicleAndDepartureTime(vehicle, 0.0);
 
 		Inserter inserter = new Inserter(new InsertionListeners(), vrp);
-        inserter.insertJob(shipment, new InsertionData(0, 0, 0, vehicle, null), route);
+		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(vrp);
 		stateManager.updateLoadStates();
 		stateManager.informInsertionStarts(Arrays.asList(route), null);
 
-        ConstraintManager constraintManager = new ConstraintManager(vrp, stateManager);
+		ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
-        constraintManager.addConstraint(new PickupAndDeliverShipmentLoadActivityLevelConstraint(stateManager), Priority.CRITICAL);
+		constraintManager.addConstraint(new PickupAndDeliverShipmentLoadActivityLevelConstraint(stateManager),Priority.CRITICAL);
-        constraintManager.addConstraint(new ShipmentPickupsFirstConstraint(), Priority.CRITICAL);
+		constraintManager.addConstraint(new ShipmentPickupsFirstConstraint(),Priority.CRITICAL);
 
 		ShipmentInsertionCalculator insertionCalculator = new ShipmentInsertionCalculator(routingCosts, activityInsertionCostsCalculator,
 				constraintManager);
@@ -264,7 +264,7 @@ public class ShipmentInsertionCalculatorTest {
 	}
 
 	@Test
-    public void whenInsertingServiceWhileNoCapIsAvailable_itMustReturnNoInsertionData() {
+	public void whenInsertingServiceWhileNoCapIsAvailable_itMustReturnNoInsertionData(){
 		Shipment shipment = Shipment.Builder.newInstance("s").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("0,10").build()).setDeliveryLocation(Location.newInstance("0,0")).build();
 		Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation(Location.Builder.newInstance().setId("10,10").build()).setDeliveryLocation(Location.newInstance("0,0")).build();
 
@@ -276,14 +276,14 @@ public class ShipmentInsertionCalculatorTest {
 
 		Inserter inserter = new Inserter(new InsertionListeners(), vrp);
 
-        inserter.insertJob(shipment, new InsertionData(0, 0, 0, vehicle, null), route);
+		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(vrp);
 		stateManager.updateLoadStates();
 		stateManager.informInsertionStarts(Arrays.asList(route), null);
 
-        ConstraintManager constraintManager = new ConstraintManager(vrp, stateManager);
+		ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
 		constraintManager.addLoadConstraint();
 
 		stateManager.informInsertionStarts(Arrays.asList(route), null);
@@ -296,7 +296,7 @@ public class ShipmentInsertionCalculatorTest {
 		switcher.put(Shipment.class, insertionCalculator);
 
 //		Service service = Service.Builder.newInstance("pick", 1).setLocationId("5,5").build();
-        Pickup service = (Pickup) Pickup.Builder.newInstance("pick").addSizeDimension(0, 1).setLocation(Location.newInstance("5,5")).build();
+		Pickup service = (Pickup)Pickup.Builder.newInstance("pick").addSizeDimension(0, 1).setLocation(Location.newInstance("5,5")).build();
 
         JobActivityFactory activityFactory = mock(JobActivityFactory.class);
         List<AbstractActivity> activities = new ArrayList<AbstractActivity>();

jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestCalculatesServiceInsertion.java

@@ -50,6 +50,8 @@ import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.mock;
 
 
+
+
 public class TestCalculatesServiceInsertion {
 
 	ServiceInsertionCalculator serviceInsertion;
@@ -73,7 +75,7 @@ public class TestCalculatesServiceInsertion {
     private VehicleRoutingProblem vrp;
 
 	@Before
-    public void setup() {
+	public void setup(){
 
 		VehicleType t1 = VehicleTypeImpl.Builder.newInstance("t1").addCapacityDimension(0, 1000).setCostPerDistance(1.0).build();
 		vehicle = VehicleImpl.Builder.newInstance("vehicle").setLatestArrival(100.0).setStartLocation(Location.newInstance("0,0")).setType(t1).build();
@@ -83,7 +85,7 @@ public class TestCalculatesServiceInsertion {
 
 		driver = DriverImpl.noDriver();
 
-        final Locations locations = new Locations() {
+		final Locations locations = new Locations(){
 
 			@Override
 			public Coordinate getCoord(String id) {
@@ -97,13 +99,13 @@ public class TestCalculatesServiceInsertion {
 		costs = new AbstractForwardVehicleRoutingTransportCosts() {
 
 			@Override
-            public double getTransportTime(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) {
+			public double getTransportTime(Location from, Location to,double departureTime, Driver driver, Vehicle vehicle) {
 				return ManhattanDistanceCalculator.calculateDistance(locations.getCoord(from.getId()), locations.getCoord(to.getId()));
 			}
 
 			@Override
 			public double getTransportCost(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) {
-                return vehicle.getType().getVehicleCostParams().perDistanceUnit * ManhattanDistanceCalculator.calculateDistance(locations.getCoord(from.getId()), locations.getCoord(to.getId()));
+				return vehicle.getType().getVehicleCostParams().perDistanceUnit*ManhattanDistanceCalculator.calculateDistance(locations.getCoord(from.getId()), locations.getCoord(to.getId()));
 			}
 		};
 
@@ -124,7 +126,7 @@ public class TestCalculatesServiceInsertion {
 		states.updateLoadStates();
 		states.updateTimeWindowStates();
 
-        ConstraintManager cManager = new ConstraintManager(vrp, states);
+		ConstraintManager cManager = new ConstraintManager(vrp,states);
 		cManager.addLoadConstraint();
 		cManager.addTimeWindowConstraint();
 
@@ -140,7 +142,7 @@ public class TestCalculatesServiceInsertion {
 	}
 
 	@Test
-    public void whenInsertingTheFirstJobInAnEmptyTourWithVehicle_itCalculatesMarginalCostChanges() {
+	public void whenInsertingTheFirstJobInAnEmptyTourWithVehicle_itCalculatesMarginalCostChanges(){
 		VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, driver).build();
 		states.informInsertionStarts(Arrays.asList(route), null);
 
@@ -150,7 +152,7 @@ public class TestCalculatesServiceInsertion {
 	}
 
 	@Test
-    public void whenInsertingTheSecondJobInAnNonEmptyTourWithVehicle_itCalculatesMarginalCostChanges() {
+	public void whenInsertingTheSecondJobInAnNonEmptyTourWithVehicle_itCalculatesMarginalCostChanges(){
 		VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, driver).setJobActivityFactory(vrp.getJobActivityFactory()).addService(first).build();
 		states.informInsertionStarts(Arrays.asList(route), null);
 
@@ -160,7 +162,7 @@ public class TestCalculatesServiceInsertion {
 	}
 
 	@Test
-    public void whenInsertingThirdJobWithVehicle_itCalculatesMarginalCostChanges() {
+	public void whenInsertingThirdJobWithVehicle_itCalculatesMarginalCostChanges(){
 		VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, driver).setJobActivityFactory(vrp.getJobActivityFactory()).addService(first).addService(third).build();
 		states.informInsertionStarts(Arrays.asList(route), null);
 
@@ -170,7 +172,7 @@ public class TestCalculatesServiceInsertion {
 	}
 
 	@Test
-    public void whenInsertingThirdJobWithNewVehicle_itCalculatesMarginalCostChanges() {
+	public void whenInsertingThirdJobWithNewVehicle_itCalculatesMarginalCostChanges(){
 		VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, driver).setJobActivityFactory(vrp.getJobActivityFactory()).addService(first).addService(third).build();
 		states.informInsertionStarts(Arrays.asList(route), null);
 
@@ -180,7 +182,7 @@ public class TestCalculatesServiceInsertion {
 	}
 
 	@Test
-    public void whenInsertingASecondJobWithAVehicle_itCalculatesLocalMarginalCostChanges() {
+	public void whenInsertingASecondJobWithAVehicle_itCalculatesLocalMarginalCostChanges(){
 		VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, driver).setJobActivityFactory(vrp.getJobActivityFactory()).addService(first).addService(second).build();
 		states.informInsertionStarts(Arrays.asList(route), null);
 
@@ -190,7 +192,7 @@ public class TestCalculatesServiceInsertion {
 	}
 
 	@Test
-    public void whenInsertingASecondJobWithANewVehicle_itCalculatesLocalMarginalCostChanges() {
+	public void whenInsertingASecondJobWithANewVehicle_itCalculatesLocalMarginalCostChanges(){
 
 		VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, driver).setJobActivityFactory(vrp.getJobActivityFactory()).addService(first).addService(second).build();
 
@@ -202,28 +204,28 @@ public class TestCalculatesServiceInsertion {
 	}
 
 	@Test
-    public void whenInsertingJobAndCurrRouteIsEmpty_accessEggressCalcShouldReturnZero() {
+	public void whenInsertingJobAndCurrRouteIsEmpty_accessEggressCalcShouldReturnZero(){
 		VehicleRoute route = VehicleRoute.Builder.newInstance(VehicleImpl.createNoVehicle(), DriverImpl.noDriver()).build();
 		AdditionalAccessEgressCalculator accessEgressCalc = new AdditionalAccessEgressCalculator(costs);
 		Job job = Service.Builder.newInstance("1").addSizeDimension(0, 0).setLocation(Location.newInstance("1")).setTimeWindow(TimeWindow.newInstance(0.0, 100.0)).build();
 		JobInsertionContext iContex = new JobInsertionContext(route, job, newVehicle, mock(Driver.class), 0.0);
-        assertEquals(0.0, accessEgressCalc.getCosts(iContex), 0.01);
+		assertEquals(0.0, accessEgressCalc.getCosts(iContex),0.01);
 	}
 
 	@Test
-    public void whenInsertingJobAndCurrRouteAndVehicleHaveTheSameLocation_accessEggressCalcShouldReturnZero() {
+	public void whenInsertingJobAndCurrRouteAndVehicleHaveTheSameLocation_accessEggressCalcShouldReturnZero(){
 		VehicleRoute route = VehicleRoute.Builder.newInstance(newVehicle, DriverImpl.noDriver())
 				.addService(first)
 				.build();
 
 		AdditionalAccessEgressCalculator accessEgressCalc = new AdditionalAccessEgressCalculator(costs);
 		JobInsertionContext iContex = new JobInsertionContext(route, first, newVehicle, mock(Driver.class), 0.0);
-        assertEquals(0.0, accessEgressCalc.getCosts(iContex), 0.01);
+		assertEquals(0.0, accessEgressCalc.getCosts(iContex),0.01);
 	}
 
 	@Test
-    public void whenInsertingJobAndCurrRouteAndNewVehicleHaveDifferentLocations_accessEggressCostsMustBeCorrect() {
+	public void whenInsertingJobAndCurrRouteAndNewVehicleHaveDifferentLocations_accessEggressCostsMustBeCorrect(){
-        final Map<String, Coordinate> coords = new HashMap<String, Coordinate>();
+		final Map<String,Coordinate> coords = new HashMap<String, Coordinate>();
 		coords.put("oldV", Coordinate.newInstance(1, 0));
 		coords.put("newV", Coordinate.newInstance(5, 0));
 		coords.put("service", Coordinate.newInstance(0, 0));
@@ -231,12 +233,12 @@ public class TestCalculatesServiceInsertion {
 		AbstractForwardVehicleRoutingTransportCosts routingCosts = new AbstractForwardVehicleRoutingTransportCosts() {
 
 			@Override
-            public double getTransportTime(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) {
+			public double getTransportTime(Location from, Location to,double departureTime, Driver driver, Vehicle vehicle) {
 				return getTransportCost(from, to, departureTime, driver, vehicle);
 			}
 
 			@Override
-            public double getTransportCost(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) {
+			public double getTransportCost(Location from, Location to,double departureTime, Driver driver, Vehicle vehicle) {
 				return EuclideanDistanceCalculator.calculateDistance(coords.get(from.getId()), coords.get(to.getId()));
 			}
 		};
@@ -251,6 +253,6 @@ public class TestCalculatesServiceInsertion {
 		AdditionalAccessEgressCalculator accessEgressCalc = new AdditionalAccessEgressCalculator(routingCosts);
 		Job job = Service.Builder.newInstance("service2").addSizeDimension(0, 0).setLocation(Location.newInstance("service")).build();
 		JobInsertionContext iContex = new JobInsertionContext(route, job, newVehicle, mock(Driver.class), 0.0);
-        assertEquals(8.0, accessEgressCalc.getCosts(iContex), 0.01);
+		assertEquals(8.0, accessEgressCalc.getCosts(iContex),0.01);
 	}
 }

jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java

@@ -16,17 +16,33 @@
  ******************************************************************************/
 package jsprit.core.algorithm.recreate;
 
+import jsprit.core.algorithm.state.StateManager;
+import jsprit.core.algorithm.state.UpdateActivityTimes;
+import jsprit.core.algorithm.state.UpdateFutureWaitingTimes;
+import jsprit.core.algorithm.state.UpdateVehicleDependentPracticalTimeWindows;
 import jsprit.core.problem.Location;
+import jsprit.core.problem.VehicleRoutingProblem;
 import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
 import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
+import jsprit.core.problem.cost.WaitingTimeCosts;
+import jsprit.core.problem.job.Job;
+import jsprit.core.problem.job.Service;
 import jsprit.core.problem.misc.JobInsertionContext;
 import jsprit.core.problem.solution.route.VehicleRoute;
 import jsprit.core.problem.solution.route.activity.End;
+import jsprit.core.problem.solution.route.activity.Start;
+import jsprit.core.problem.solution.route.activity.TimeWindow;
 import jsprit.core.problem.solution.route.activity.TourActivity;
 import jsprit.core.problem.vehicle.Vehicle;
+import jsprit.core.problem.vehicle.VehicleImpl;
+import jsprit.core.problem.vehicle.VehicleTypeImpl;
+import jsprit.core.util.CostFactory;
 import org.junit.Before;
 import org.junit.Test;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -46,7 +62,7 @@ public class TestLocalActivityInsertionCostsCalculator {
 	JobInsertionContext jic;
 
 	@Before
-    public void doBefore() {
+	public void doBefore(){
 
 		vehicle = mock(Vehicle.class);
 		route = mock(VehicleRoute.class);
@@ -56,6 +72,7 @@ public class TestLocalActivityInsertionCostsCalculator {
 		jic = mock(JobInsertionContext.class);
 		when(jic.getRoute()).thenReturn(route);
 		when(jic.getNewVehicle()).thenReturn(vehicle);
+		when(vehicle.getType()).thenReturn(VehicleTypeImpl.Builder.newInstance("type").build());
 
 		tpCosts = mock(VehicleRoutingTransportCosts.class);
 		when(tpCosts.getTransportCost(loc("i"), loc("j"), 0.0, null, vehicle)).thenReturn(2.0);
@@ -66,7 +83,7 @@ public class TestLocalActivityInsertionCostsCalculator {
 		when(tpCosts.getTransportTime(loc("k"), loc("j"), 0.0, null, vehicle)).thenReturn(0.0);
 
 		actCosts = mock(VehicleRoutingActivityCosts.class);
-        calc = new LocalActivityInsertionCostsCalculator(tpCosts, actCosts);
+		calc = new LocalActivityInsertionCostsCalculator(tpCosts, actCosts, mock(StateManager.class));
 	}
 
     private Location loc(String i) {
@@ -74,60 +91,423 @@ public class TestLocalActivityInsertionCostsCalculator {
     }
 
     @Test
-    public void whenInsertingActBetweenTwoRouteActs_itCalcsMarginalTpCosts() {
+	public void whenInsertingActBetweenTwoRouteActs_itCalcsMarginalTpCosts(){
 		TourActivity prevAct = mock(TourActivity.class);
 		when(prevAct.getLocation()).thenReturn(loc("i"));
+		when(prevAct.getIndex()).thenReturn(1);
 		TourActivity nextAct = mock(TourActivity.class);
 		when(nextAct.getLocation()).thenReturn(loc("j"));
+		when(nextAct.getIndex()).thenReturn(1);
 		TourActivity newAct = mock(TourActivity.class);
 		when(newAct.getLocation()).thenReturn(loc("k"));
+		when(newAct.getIndex()).thenReturn(1);
 
 		when(vehicle.isReturnToDepot()).thenReturn(true);
 
 		double costs = calc.getCosts(jic, prevAct, nextAct, newAct, 0.0);
-        assertEquals(4.0, costs, 0.01);
+		assertEquals(4.0,costs,0.01);
 	}
 
 	@Test
-    public void whenInsertingActBetweenLastActAndEnd_itCalcsMarginalTpCosts() {
+	public void whenInsertingActBetweenLastActAndEnd_itCalcsMarginalTpCosts(){
 		TourActivity prevAct = mock(TourActivity.class);
 		when(prevAct.getLocation()).thenReturn(loc("i"));
+		when(prevAct.getIndex()).thenReturn(1);
 		End nextAct = End.newInstance("j", 0.0, 0.0);
 		TourActivity newAct = mock(TourActivity.class);
 		when(newAct.getLocation()).thenReturn(loc("k"));
+		when(newAct.getIndex()).thenReturn(1);
 
 		when(vehicle.isReturnToDepot()).thenReturn(true);
 
 		double costs = calc.getCosts(jic, prevAct, nextAct, newAct, 0.0);
-        assertEquals(4.0, costs, 0.01);
+		assertEquals(4.0,costs,0.01);
 	}
 
 	@Test
-    public void whenInsertingActBetweenTwoRouteActsAndRouteIsOpen_itCalcsMarginalTpCosts() {
+	public void whenInsertingActBetweenTwoRouteActsAndRouteIsOpen_itCalcsMarginalTpCosts(){
 		TourActivity prevAct = mock(TourActivity.class);
 		when(prevAct.getLocation()).thenReturn(loc("i"));
+		when(prevAct.getIndex()).thenReturn(1);
 		TourActivity nextAct = mock(TourActivity.class);
 		when(nextAct.getLocation()).thenReturn(loc("j"));
+		when(nextAct.getIndex()).thenReturn(1);
 		TourActivity newAct = mock(TourActivity.class);
 		when(newAct.getLocation()).thenReturn(loc("k"));
+		when(newAct.getIndex()).thenReturn(1);
 
 		when(vehicle.isReturnToDepot()).thenReturn(false);
 
 		double costs = calc.getCosts(jic, prevAct, nextAct, newAct, 0.0);
-        assertEquals(4.0, costs, 0.01);
+		assertEquals(4.0,costs,0.01);
 	}
 
 	@Test
-    public void whenInsertingActBetweenLastActAndEndAndRouteIsOpen_itCalculatesTpCostsFromPrevToNewAct() {
+	public void whenInsertingActBetweenLastActAndEndAndRouteIsOpen_itCalculatesTpCostsFromPrevToNewAct(){
 		TourActivity prevAct = mock(TourActivity.class);
 		when(prevAct.getLocation()).thenReturn(loc("i"));
+		when(prevAct.getIndex()).thenReturn(1);
 		End nextAct = End.newInstance("j", 0.0, 0.0);
 		TourActivity newAct = mock(TourActivity.class);
 		when(newAct.getLocation()).thenReturn(loc("k"));
+		when(newAct.getIndex()).thenReturn(1);
 
 		when(vehicle.isReturnToDepot()).thenReturn(false);
 
 		double costs = calc.getCosts(jic, prevAct, nextAct, newAct, 0.0);
-        assertEquals(3.0, costs, 0.01);
+		assertEquals(3.0,costs,0.01);
+	}
+
+	@Test
+	public void test(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0, 0)).build();
+		Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build();
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(60, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,80)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build();
+
+		TourActivity prevAct = vrp.getActivities(prevS).get(0);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).build();
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(), new StateManager(mock(VehicleRoutingProblem.class)));
+		calc.setSolutionCompletenessRatio(1.);
+
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
+		assertEquals(50.,c,0.01);
+
+		/*
+		new: dist = 90 & wait = 0
+		old: dist = 30 & wait = 10
+		c = new - old = 90 - 40 = 50
+		 */
+	}
+
+	@Test
+	public void whenAddingNewBetweenStartAndAct_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30, 0))
+				.setTimeWindow(TimeWindow.newInstance(40, 50)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(newS).addJob(nextS).addVehicle(v).build();
+
+		Start prevAct = new Start(Location.newInstance(0,0),0,100);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(nextS).build();
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(vrp));
+		calc.setSolutionCompletenessRatio(1.);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,0);
+		assertEquals(-10.,c,0.01);
+	}
+
+	@Test
+	public void whenAddingNewBetweenStartAndAct2_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+
+		VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0))
+				.setTimeWindow(TimeWindow.newInstance(140,150)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(newS).addJob(nextS).addVehicle(v2).build();
+
+		Start prevAct = new Start(Location.newInstance(0,0),0,100);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v2).setJobActivityFactory(vrp.getJobActivityFactory()).addService(nextS).build();
+		JobInsertionContext context = new JobInsertionContext(route,newS,v2,null,0.);
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(), new StateManager(vrp));
+		calc.setSolutionCompletenessRatio(1.);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,0);
+		assertEquals(-10.,c,0.01);
+	}
+
+	@Test
+	public void whenAddingNewInEmptyRoute_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).setTimeWindow(TimeWindow.newInstance(100, 150)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(newS).addVehicle(v).build();
+
+		Start prevAct = new Start(Location.newInstance(0,0),0,100);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		End nextAct = new End(Location.newInstance(0,0),0,100);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).build();
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(vrp) );
+		calc.setSolutionCompletenessRatio(1.);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,0);
+		assertEquals(110.,c,0.01);
+	}
+
+	@Test
+	public void whenAddingNewBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10, 0)).build();
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(20, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,50)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build();
+
+		TourActivity prevAct = vrp.getActivities(prevS).get(0);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).build();
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(vrp) );
+		calc.setSolutionCompletenessRatio(1.);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
+		assertEquals(-10.,c,0.01);
+	}
+
+	@Test
+	public void whenAddingNewWithTWBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build();
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100, 120)).setLocation(Location.newInstance(20, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build();
+
+		TourActivity prevAct = vrp.getActivities(prevS).get(0);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).build();
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(vrp) );
+		calc.setSolutionCompletenessRatio(0.5);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
+		assertEquals(35.,c,0.01);
+	}
+
+	@Test
+	public void whenAddingNewWithTWBetweenTwoActs2_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+//		VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build();
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100,120)).setLocation(Location.newInstance(20, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build();
+
+		Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(400,500)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(afterNextS).addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build();
+
+		TourActivity prevAct = vrp.getActivities(prevS).get(0);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).build();
+
+		StateManager stateManager = getStateManager(vrp,route);
+
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager);
+		calc.setSolutionCompletenessRatio(1.);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
+		assertEquals(-10.,c,0.01);
+		//
+		//old: dist: 0, waiting: 10 + 350 = 360
+		//new: dist: 0, waiting: 80 + 270 = 350
+	}
+
+	@Test
+	public void whenAddingNewWithTWBetweenTwoActs3_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+//		VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build();
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100, 120)).setLocation(Location.newInstance(20, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30, 0)).setTimeWindow(TimeWindow.newInstance(40, 500)).build();
+
+		Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(80, 500)).build();
+		Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(100, 500)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS)
+				.addJob(afterNextS).addJob(afterAfterNextS).build();
+
+		TourActivity prevAct = vrp.getActivities(prevS).get(0);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build();
+
+		StateManager stateManager = getStateManager(vrp, route);
+
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager);
+		calc.setSolutionCompletenessRatio(1.);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
+		assertEquals(20.,c,0.01);
+		//start-delay = new - old = 120 - 40 = 80 > future waiting time savings = 30 + 20 + 10
+		//ref: 10 + 50 + 20 = 80
+		//new: 80 - 10 - 30 - 20 = 20
+		/*
+		w(new) + w(next) - w_old(next) - min{start_delay(next),future_waiting}
+		 */
+	}
+
+	@Test
+	public void whenAddingNewWithTWBetweenTwoActs4_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+//		VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build();
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100,120)).setLocation(Location.newInstance(20, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build();
+
+		Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(80,500)).build();
+		Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS)
+				.addJob(afterNextS).addJob(afterAfterNextS).build();
+
+		TourActivity prevAct = vrp.getActivities(prevS).get(0);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build();
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+
+		StateManager stateManager = getStateManager(vrp, route);
+
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager);
+		calc.setSolutionCompletenessRatio(1.);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
+		assertEquals(30.,c,0.01);
+		//ref: 10 + 30 + 10 = 50
+		//new: 50 - 50 = 0
+
+		/*
+		activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings
+		 */
+		/*
+		old = 10 + 30 + 10 = 50
+		new = 80 + 0 - 10 - min{80,40} = 30
+		 */
+	}
+
+	@Test
+	public void whenAddingNewWithTWBetweenTwoActs4WithVarStart_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+//		VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build();
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100,120)).setLocation(Location.newInstance(20, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build();
+
+		Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(80,500)).build();
+		Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS)
+				.addJob(afterNextS).addJob(afterAfterNextS).build();
+
+		TourActivity prevAct = vrp.getActivities(prevS).get(0);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build();
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+
+		StateManager stateManager = getStateManager(vrp, route);
+
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager);
+		calc.setSolutionCompletenessRatio(1.);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
+		assertEquals(30.,c,0.01);
+		/*
+		activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings
+		 */
+		/*
+		old = 10 + 30 + 10 = 50
+		new = 80
+		new - old = 80 - 40 = 40
+
+		 */
+	}
+
+	@Test
+	public void whenAddingNewWithTWBetweenTwoActs3WithVarStart_itShouldCalcInsertionCostsCorrectly(){
+		VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
+
+		VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build();
+//		VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build();
+
+		Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build();
+		Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(50,70)).setLocation(Location.newInstance(20, 0)).build();
+		Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,70)).build();
+
+		Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(50,100)).build();
+		Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build();
+
+		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS)
+				.addJob(afterNextS).addJob(afterAfterNextS).build();
+
+		TourActivity prevAct = vrp.getActivities(prevS).get(0);
+		TourActivity newAct = vrp.getActivities(newS).get(0);
+		TourActivity nextAct = vrp.getActivities(nextS).get(0);
+
+		VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build();
+		JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
+
+		StateManager stateManager = getStateManager(vrp, route);
+
+		LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager);
+		calc.setSolutionCompletenessRatio(1.);
+		double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
+		assertEquals(-10.,c,0.01);
+		/*
+		activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings
+		 */
+		/*
+		old = 10 + 40 = 50
+		new = 30 + 10 = 40
+		 */
+	}
+
+
+
+
+
+
+	private StateManager getStateManager(VehicleRoutingProblem vrp, VehicleRoute route) {
+		StateManager stateManager = new StateManager(vrp);
+		stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts()));
+		stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,vrp.getTransportCosts()));
+		stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts()));
+		stateManager.informInsertionStarts(Arrays.asList(route),new ArrayList<Job>());
+		return stateManager;
 	}
 }

jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java

@@ -34,6 +34,35 @@ public class VehicleImplTest {
         Vehicle v = VehicleImpl.Builder.newInstance("v").build();
     }
 
+	@Test
+	public void whenAddingSkills_theyShouldBeAddedCorrectly(){
+		VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type").build();
+		Vehicle v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("start")).setType(type1).setEndLocation(Location.newInstance("start"))
+				.addSkill("drill").addSkill("screwdriver").build();
+		assertTrue(v.getSkills().containsSkill("drill"));
+		assertTrue(v.getSkills().containsSkill("drill"));
+		assertTrue(v.getSkills().containsSkill("screwdriver"));
+	}
+
+	@Test
+	public void whenAddingSkillsCaseSens_theyShouldBeAddedCorrectly(){
+		VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type").build();
+		Vehicle v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("start")).setType(type1).setEndLocation(Location.newInstance("start"))
+				.addSkill("drill").addSkill("screwdriver").build();
+		assertTrue(v.getSkills().containsSkill("drill"));
+		assertTrue(v.getSkills().containsSkill("dRill"));
+		assertTrue(v.getSkills().containsSkill("ScrewDriver"));
+	}
+
+	@Test
+	public void whenAddingSkillsCaseSensV2_theyShouldBeAddedCorrectly(){
+		VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type").build();
+		Vehicle v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("start")).setType(type1).setEndLocation(Location.newInstance("start"))
+				.addSkill("drill").build();
+		assertFalse(v.getSkills().containsSkill("ScrewDriver"));
+	}
+
+
     @Test
     public void whenVehicleIsBuiltToReturnToDepot_itShouldReturnToDepot() {
         Vehicle v = VehicleImpl.Builder.newInstance("v").setReturnToDepot(true).setStartLocation(Location.newInstance("loc")).build();

jsprit-examples/src/main/java/jsprit/examples/CostMatrixExample.java

@@ -18,7 +18,7 @@ package jsprit.examples;
 
 import jsprit.analysis.toolbox.Plotter;
 import jsprit.core.algorithm.VehicleRoutingAlgorithm;
-import jsprit.core.algorithm.io.VehicleRoutingAlgorithms;
+import jsprit.core.algorithm.box.Jsprit;
 import jsprit.core.problem.Location;
 import jsprit.core.problem.VehicleRoutingProblem;
 import jsprit.core.problem.VehicleRoutingProblem.FleetSize;
@@ -40,6 +40,7 @@ import java.util.Collection;
  * Illustrates how you can use jsprit with an already compiled distance and time matrix.
  *
  * @author schroeder
+ *
  */
 public class CostMatrixExample {
 
@@ -97,7 +98,7 @@ public class CostMatrixExample {
 		VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().setFleetSize(FleetSize.INFINITE).setRoutingCost(costMatrix)
 				.addVehicle(vehicle).addJob(s1).addJob(s2).addJob(s3).build();
 
-        VehicleRoutingAlgorithm vra = VehicleRoutingAlgorithms.readAndCreateAlgorithm(vrp, "input/fastAlgo.xml");
+		VehicleRoutingAlgorithm vra = Jsprit.createAlgorithm(vrp);
 
 		Collection<VehicleRoutingProblemSolution> solutions = vra.searchSolutions();
 

jsprit-examples/src/main/java/jsprit/examples/WaitingTimeExample.java

@@ -0,0 +1,74 @@
+package jsprit.examples;
+
+import jsprit.analysis.toolbox.AlgorithmSearchProgressChartListener;
+import jsprit.analysis.toolbox.Plotter;
+import jsprit.core.algorithm.VehicleRoutingAlgorithm;
+import jsprit.core.algorithm.box.Jsprit;
+import jsprit.core.analysis.SolutionAnalyser;
+import jsprit.core.problem.Location;
+import jsprit.core.problem.VehicleRoutingProblem;
+import jsprit.core.problem.cost.TransportDistance;
+import jsprit.core.problem.job.Service;
+import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import jsprit.core.problem.solution.route.activity.TimeWindow;
+import jsprit.core.problem.vehicle.VehicleImpl;
+import jsprit.core.problem.vehicle.VehicleTypeImpl;
+import jsprit.core.reporting.SolutionPrinter;
+import jsprit.core.util.RandomNumberGeneration;
+import jsprit.core.util.Solutions;
+
+import java.util.Random;
+
+/**
+ * Created by schroeder on 23/07/15.
+ */
+public class WaitingTimeExample {
+
+    public static void main(String[] args) {
+
+        VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(4.).setCostPerWaitingTime(1.0).build();
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(4.).setCostPerWaitingTime(1.0).build();
+
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(true)
+                .setStartLocation(Location.newInstance(0, 0))
+                .setEarliestStart(0).setLatestArrival(220)
+                .build();
+        VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type1).setReturnToDepot(true)
+                .setStartLocation(Location.newInstance(0, 10))
+                .setEarliestStart(200).setLatestArrival(450)
+                .build();
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        Random r = RandomNumberGeneration.newInstance();
+        for(int i=0;i<40;i++){
+            Service s = Service.Builder.newInstance("s_"+i).setServiceTime(5)
+                    .setLocation(Location.newInstance(1 - r.nextInt(5), 10 + r.nextInt(10))).build();
+            vrpBuilder.addJob(s);
+        }
+        Service s1 = Service.Builder.newInstance("s12").setLocation(Location.newInstance(-3, 15)).setTimeWindow(TimeWindow.newInstance(290, 600)).build();
+        Service s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(0,20)).setTimeWindow(TimeWindow.newInstance(290, 340)).build();
+        Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(-1, 15)).setTimeWindow(TimeWindow.newInstance(300, 350)).build();
+        Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(10, 10)).setTimeWindow(TimeWindow.newInstance(400, 600)).build();
+        vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addJob(s4).addVehicle(v2).addVehicle(v3);
+        vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE);
+        final VehicleRoutingProblem vrp = vrpBuilder.build();
+
+        VehicleRoutingAlgorithm vra = Jsprit.createAlgorithm(vrp);
+        vra.setMaxIterations(2000);
+        vra.addListener(new AlgorithmSearchProgressChartListener("output/search"));
+        VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions());
+        System.out.println("c: " + solution.getCost());
+        SolutionPrinter.print(vrp, solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser sa = new SolutionAnalyser(vrp, solution, new TransportDistance() {
+            @Override
+            public double getDistance(Location from, Location to) {
+                return vrp.getTransportCosts().getTransportTime(from,to,0.,null,null);
+            }
+        });
+
+        System.out.println("totalWaiting: " + sa.getWaitingTime());
+        System.out.println("brokenTWs: " + sa.getTimeWindowViolation());
+
+        new Plotter(vrp,solution).setLabel(Plotter.Label.ID).plot("output/plot","plot");
+    }
+}

jsprit-examples/src/main/java/jsprit/examples/WaitingTimeExample2.java

@@ -0,0 +1,90 @@
+package jsprit.examples;
+
+import jsprit.analysis.toolbox.AlgorithmSearchProgressChartListener;
+import jsprit.analysis.toolbox.Plotter;
+import jsprit.core.algorithm.VehicleRoutingAlgorithm;
+import jsprit.core.algorithm.box.Jsprit;
+import jsprit.core.problem.Location;
+import jsprit.core.problem.VehicleRoutingProblem;
+import jsprit.core.problem.job.Service;
+import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import jsprit.core.problem.solution.route.activity.TimeWindow;
+import jsprit.core.problem.vehicle.VehicleImpl;
+import jsprit.core.problem.vehicle.VehicleTypeImpl;
+import jsprit.core.reporting.SolutionPrinter;
+import jsprit.core.util.Solutions;
+
+/**
+ * Created by schroeder on 23/07/15.
+ */
+public class WaitingTimeExample2 {
+
+    static interface AlgorithmFactory {
+        VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vrp);
+    }
+
+    public static void main(String[] args) {
+
+        VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.5).setCostPerWaitingTime(1.).build();
+//        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(1.5).setCostPerWaitingTime(.0).build();
+
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(true)
+                .setStartLocation(Location.newInstance(0, 0)).build();
+
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+
+
+        Service s1 = Service.Builder.newInstance("s12").setLocation(Location.newInstance(-1, 5)).setTimeWindow(TimeWindow.newInstance(100, 110)).build();
+        Service s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(0, 10)).build();
+        Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(1, 12)).build();
+        Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(4, 10)).build();
+        Service s5 = Service.Builder.newInstance("s14").setLocation(Location.newInstance(6, 5)).setTimeWindow(TimeWindow.newInstance(110,220)).build();
+        vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addJob(s4).addJob(s5).addVehicle(v2);
+        vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE);
+        final VehicleRoutingProblem vrp = vrpBuilder.build();
+
+//        AlgorithmFactory algorithmFactory = new AlgorithmFactory() {
+//            @Override
+//            public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) {
+//                StateManager stateManager = new StateManager(vrp);
+//                stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts()));
+//                ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
+//
+//                return  Jsprit.Builder.newInstance(vrp)
+//                        .addCoreStateAndConstraintStuff(true)
+//                        .setStateAndConstraintManager(stateManager, constraintManager)
+////                        .setProperty(Jsprit.Parameter.THRESHOLD_INI, "0.1")
+////                        .setProperty(Jsprit.Parameter.THRESHOLD_ALPHA, "0.3")
+////                                .setProperty(Parameter.)
+////                        .setProperty(Jsprit.Parameter.CONSTRUCTION, Jsprit.Construction.BEST_INSERTION.toString())
+//                        .setObjectiveFunction(new SolutionCostCalculator() {
+//                            @Override
+//                            public double getCosts(VehicleRoutingProblemSolution solution) {
+//                                double costs = 0.;
+//                                for (VehicleRoute route : solution.getRoutes()) {
+//                                    costs += route.getVehicle().getType().getVehicleCostParams().fix;
+//                                    TourActivity prevAct = route.getStart();
+//                                    for (TourActivity act : route.getActivities()) {
+//                                        costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(), act.getLocation(), prevAct.getEndTime(), route.getDriver(), route.getVehicle());
+//                                        costs += vrp.getActivityCosts().getActivityCost(act, act.getArrTime(), route.getDriver(), route.getVehicle());
+//                                        prevAct = act;
+//                                    }
+//                                    costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(), route.getEnd().getLocation(), prevAct.getEndTime(), route.getDriver(), route.getVehicle());
+//                                }
+//                                costs += solution.getUnassignedJobs().size() * 200;
+//                                return costs;
+//                            }
+//                        })
+//                        .buildAlgorithm();
+//            }
+//        };
+        VehicleRoutingAlgorithm vra = Jsprit.createAlgorithm(vrp);
+        vra.setMaxIterations(1000);
+        vra.addListener(new AlgorithmSearchProgressChartListener("output/search"));
+        VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions());
+        System.out.println("c: " + solution.getCost());
+        SolutionPrinter.print(vrp, solution, SolutionPrinter.Print.VERBOSE);
+
+        new Plotter(vrp,solution).setLabel(Plotter.Label.ID).plot("output/plot","plot");
+    }
+}