relax api - move constraints of serviceCalc

jsprit-core/src/main/java/algorithms/BestInsertionBuilder.java

@@ -22,6 +22,8 @@ public class BestInsertionBuilder implements InsertionStrategyBuilder{
 	private double weightOfFixedCosts;
 
 	private boolean considerFixedCosts = false;
+
+	private ActivityInsertionCostsCalculator actInsertionCostsCalculator = null;
 	
 	public BestInsertionBuilder(VehicleRoutingProblem vrp, StateManager stateManager) {
 		super();
@@ -58,7 +60,9 @@ public class BestInsertionBuilder implements InsertionStrategyBuilder{
 		return this;
 	}
 	
-	//public void setActivityInsertionCostCalculator(ActivityInsertionCostCalculator costCalc){};
+	public void setActivityInsertionCostCalculator(ActivityInsertionCostsCalculator activityInsertionCostsCalculator){
+		this.actInsertionCostsCalculator = activityInsertionCostsCalculator;
+	};
 	
 	@Override
 	public InsertionStrategy build() {
@@ -72,6 +76,7 @@ public class BestInsertionBuilder implements InsertionStrategyBuilder{
 		calcBuilder.setStates(stateManager);
 		calcBuilder.setVehicleRoutingProblem(vrp);
 		calcBuilder.setVehicleFleetManager(fleetManager);
+		calcBuilder.setActivityInsertionCostsCalculator(actInsertionCostsCalculator);
 		if(considerFixedCosts) calcBuilder.considerFixedCosts(weightOfFixedCosts);
 		JobInsertionCalculator jobInsertions = calcBuilder.build();
 		BestInsertion bestInsertion = new BestInsertion(jobInsertions);

jsprit-core/src/main/java/algorithms/CalculatorBuilder.java

@@ -79,6 +79,8 @@ class CalculatorBuilder {
 	private int neighbors;
 	
 	private ConstraintManager constraintManager;
+	
+	private ActivityInsertionCostsCalculator activityInsertionCostCalculator = null;
 
 	/**
 	 * Constructs the builder.
@@ -136,6 +138,10 @@ class CalculatorBuilder {
 	public void setLocalLevel(){
 		local = true;
 	}
+	
+	public void setActivityInsertionCostsCalculator(ActivityInsertionCostsCalculator activityInsertionCostsCalculator){
+		this.activityInsertionCostCalculator = activityInsertionCostsCalculator;
+	}
 
 	/**
 	 * Sets a flag to build a calculator that evaluates job insertion on route-level.
@@ -214,11 +220,16 @@ class CalculatorBuilder {
 	private CalculatorPlusListeners createStandardLocal(VehicleRoutingProblem vrp, StateManager statesManager){
 		if(constraintManager == null) throw new IllegalStateException("constraint-manager is null");
  		
-		ActivityInsertionCostsCalculator defaultCalc = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), constraintManager);
+		ActivityInsertionCostsCalculator actInsertionCalc;
+		if(activityInsertionCostCalculator == null){
+			actInsertionCalc = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts());
+		}
+		else{
+			actInsertionCalc = activityInsertionCostCalculator;
+		}
 
-		JobInsertionCalculator standardServiceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), defaultCalc, constraintManager);
+		JobInsertionCalculator standardServiceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), actInsertionCalc, constraintManager, constraintManager);
-		
+		((ServiceInsertionCalculator) standardServiceInsertion).setNeighborhood(vrp.getNeighborhood());
-		((CalculatesServiceInsertion) standardServiceInsertion).setNeighborhood(vrp.getNeighborhood());
 		CalculatorPlusListeners calcPlusListeners = new CalculatorPlusListeners(standardServiceInsertion);
 		
 		return calcPlusListeners;
@@ -234,12 +245,18 @@ class CalculatorBuilder {
 
 	private CalculatorPlusListeners createStandardRoute(VehicleRoutingProblem vrp, StateManager activityStates2, int forwardLooking, int solutionMemory){
 		int after = forwardLooking;
-		ActivityInsertionCostsCalculator routeLevelCostEstimator = new RouteLevelActivityInsertionCostsEstimator(vrp.getTransportCosts(), vrp.getActivityCosts(), constraintManager, activityStates2);
+		ActivityInsertionCostsCalculator routeLevelCostEstimator;
-		JobInsertionCalculator jobInsertionCalculator = new CalculatesServiceInsertionOnRouteLevel(vrp.getTransportCosts(), vrp.getActivityCosts(), constraintManager, routeLevelCostEstimator);
+		if(activityInsertionCostCalculator == null){
-		((CalculatesServiceInsertionOnRouteLevel)jobInsertionCalculator).setNuOfActsForwardLooking(after);
+			routeLevelCostEstimator = new RouteLevelActivityInsertionCostsEstimator(vrp.getTransportCosts(), vrp.getActivityCosts(), activityStates2);
-		((CalculatesServiceInsertionOnRouteLevel)jobInsertionCalculator).setMemorySize(solutionMemory);
+		}
-		((CalculatesServiceInsertionOnRouteLevel)jobInsertionCalculator).setNeighborhood(vrp.getNeighborhood());
+		else{
-		((CalculatesServiceInsertionOnRouteLevel) jobInsertionCalculator).setStates(activityStates2);
+			routeLevelCostEstimator = activityInsertionCostCalculator;
+		}
+		JobInsertionCalculator jobInsertionCalculator = new ServiceInsertionOnRouteLevelCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), routeLevelCostEstimator, constraintManager, constraintManager);
+		((ServiceInsertionOnRouteLevelCalculator)jobInsertionCalculator).setNuOfActsForwardLooking(after);
+		((ServiceInsertionOnRouteLevelCalculator)jobInsertionCalculator).setMemorySize(solutionMemory);
+		((ServiceInsertionOnRouteLevelCalculator)jobInsertionCalculator).setNeighborhood(vrp.getNeighborhood());
+		((ServiceInsertionOnRouteLevelCalculator) jobInsertionCalculator).setStates(activityStates2);
 		CalculatorPlusListeners calcPlusListener = new CalculatorPlusListeners(jobInsertionCalculator);
 		return calcPlusListener;
 	}

jsprit-core/src/main/java/algorithms/LocalActivityInsertionCostsCalculator.java

@@ -26,23 +26,17 @@ import basics.route.TourActivity;
 
 class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCalculator{
 
-	private HardActivityLevelConstraint hardConstraint;
-
 	private VehicleRoutingTransportCosts routingCosts;
 	private VehicleRoutingActivityCosts activityCosts;
 	
-	public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, HardActivityLevelConstraint hardActivityLevelConstraint) {
+	public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts) {
 		super();
 		this.routingCosts = routingCosts;
 		this.activityCosts = actCosts;
-		this.hardConstraint = hardActivityLevelConstraint;
 	}
 
 	@Override
 	public ActivityInsertionCosts calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) {
-		if(!hardConstraint.fulfilled(iFacts, prevAct, newAct, nextAct, depTimeAtPrevAct)){
-			return null;
-		}
 		
 		double tp_costs_prevAct_newAct = routingCosts.getTransportCost(prevAct.getLocationId(), newAct.getLocationId(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
 		double tp_time_prevAct_newAct = routingCosts.getTransportTime(prevAct.getLocationId(), newAct.getLocationId(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());

jsprit-core/src/main/java/algorithms/RouteLevelActivityInsertionCostsEstimator.java

@@ -32,8 +32,6 @@ import basics.route.VehicleRoute;
 
 class RouteLevelActivityInsertionCostsEstimator implements ActivityInsertionCostsCalculator{
 
-	private HardActivityLevelConstraint hardConstraint;
-
 	private VehicleRoutingActivityCosts activityCosts;
 	
 	private AuxilliaryCostCalculator auxilliaryPathCostCalculator;
@@ -42,20 +40,15 @@ class RouteLevelActivityInsertionCostsEstimator implements ActivityInsertionCost
 	
 	private int nuOfActivities2LookForward = 0;
 	
-	public RouteLevelActivityInsertionCostsEstimator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, HardActivityLevelConstraint hardActivityLevelConstraint, StateManager stateManager) {
+	public RouteLevelActivityInsertionCostsEstimator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, StateManager stateManager) {
 		super();
 		this.activityCosts = actCosts;
-		this.hardConstraint = hardActivityLevelConstraint;
 		this.stateManager = stateManager;
 		auxilliaryPathCostCalculator = new AuxilliaryCostCalculator(routingCosts, activityCosts);
 	}
 
 	@Override
 	public ActivityInsertionCosts calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) {
-		if(!hardConstraint.fulfilled(iFacts, prevAct, newAct, nextAct, depTimeAtPrevAct)){
-			return null;
-		}
-		
 		List<TourActivity> path = new ArrayList<TourActivity>();
 		path.add(prevAct); path.add(newAct); path.add(nextAct);
 		int actIndex;

jsprit-core/src/main/java/algorithms/ServiceInsertionCalculator.java

@@ -35,12 +35,14 @@ import basics.route.VehicleRoute;
 
 
 
-final class CalculatesServiceInsertion implements JobInsertionCalculator{
+final class ServiceInsertionCalculator implements JobInsertionCalculator{
 
-	private static final Logger logger = Logger.getLogger(CalculatesServiceInsertion.class);
+	private static final Logger logger = Logger.getLogger(ServiceInsertionCalculator.class);
 
 	private HardRouteLevelConstraint hardRouteLevelConstraint;
 	
+	private HardActivityLevelConstraint hardActivityLevelConstraint;
+	
 	private Neighborhood neighborhood = new Neighborhood() {
 		
 		@Override
@@ -61,10 +63,11 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 	}
 	
 
-	public CalculatesServiceInsertion(VehicleRoutingTransportCosts routingCosts, ActivityInsertionCostsCalculator activityInsertionCostsCalculator, HardRouteLevelConstraint hardRouteLevelConstraint) {
+	public ServiceInsertionCalculator(VehicleRoutingTransportCosts routingCosts, ActivityInsertionCostsCalculator activityInsertionCostsCalculator, HardRouteLevelConstraint hardRouteLevelConstraint, HardActivityLevelConstraint hardActivityLevelConstraint) {
 		super();
 		this.activityInsertionCostsCalculator = activityInsertionCostsCalculator;
 		this.hardRouteLevelConstraint = hardRouteLevelConstraint;
+		this.hardActivityLevelConstraint = hardActivityLevelConstraint;
 		this.transportCosts = routingCosts;
 		activityFactory = new DefaultTourActivityFactory();
 		logger.info("initialise " + this);
@@ -108,8 +111,8 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 
 		for(TourActivity nextAct : currentRoute.getTourActivities().getActivities()){
 			if(neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), nextAct.getLocationId())){
-				ActivityInsertionCosts mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
+				if(hardActivityLevelConstraint.fulfilled(insertionContext, prevAct, deliveryAct2Insert, nextAct, prevActStartTime)){
-				if(mc != null){ 
+					ActivityInsertionCosts mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
 					if(mc.getAdditionalCosts() < bestCost){
 						bestCost = mc.getAdditionalCosts();
 						bestMarginals = mc;
@@ -127,8 +130,8 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 		}
 		End nextAct = end;
 		if(neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), nextAct.getLocationId())){
-			ActivityInsertionCosts mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
+			if(hardActivityLevelConstraint.fulfilled(insertionContext, prevAct, deliveryAct2Insert, nextAct, prevActStartTime)){
-			if(mc != null) {
+				ActivityInsertionCosts mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
 				if(mc.getAdditionalCosts() < bestCost){
 					bestCost = mc.getAdditionalCosts();
 					bestMarginals = mc;

jsprit-core/src/main/java/algorithms/ServiceInsertionOnRouteLevelCalculator.java

@@ -44,9 +44,9 @@ import basics.route.VehicleRoute;
 
 
 
-final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalculator{
+final class ServiceInsertionOnRouteLevelCalculator implements JobInsertionCalculator{
 	
-	private static final Logger logger = Logger.getLogger(CalculatesServiceInsertionOnRouteLevel.class);
+	private static final Logger logger = Logger.getLogger(ServiceInsertionOnRouteLevelCalculator.class);
 	
 	private final VehicleRoutingTransportCosts transportCosts;
 	
@@ -60,6 +60,8 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 	
 	private HardRouteLevelConstraint hardRouteLevelConstraint;
 	
+	private HardActivityLevelConstraint hardActivityLevelConstraint;
+	
 	private ActivityInsertionCostsCalculator activityInsertionCostsCalculator;
 	
 	private int nuOfActsForwardLooking = 0;
@@ -93,12 +95,13 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		logger.info("set [solutionMemory="+memorySize+"]");
 	}
 
-	public CalculatesServiceInsertionOnRouteLevel(VehicleRoutingTransportCosts vehicleRoutingCosts, VehicleRoutingActivityCosts costFunc, HardRouteLevelConstraint hardRouteLevelConstraint, ActivityInsertionCostsCalculator activityInsertionCostsCalculator) {
+	public ServiceInsertionOnRouteLevelCalculator(VehicleRoutingTransportCosts vehicleRoutingCosts, VehicleRoutingActivityCosts costFunc, ActivityInsertionCostsCalculator activityInsertionCostsCalculator, HardRouteLevelConstraint hardRouteLevelConstraint, HardActivityLevelConstraint hardActivityLevelConstraint) {
 			super();
 			this.transportCosts = vehicleRoutingCosts;
 			this.activityCosts = costFunc;
-			this.hardRouteLevelConstraint = hardRouteLevelConstraint;
 			this.activityInsertionCostsCalculator = activityInsertionCostsCalculator;
+			this.hardRouteLevelConstraint = hardRouteLevelConstraint;
+			this.hardActivityLevelConstraint = hardActivityLevelConstraint;
 			auxilliaryPathCostCalculator = new AuxilliaryCostCalculator(transportCosts, activityCosts);
 			logger.info("initialise " + this);
 		}
@@ -172,12 +175,12 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		 */
 		for(TourActivity nextAct : tour.getActivities()){
 			if(neighborhood.areNeighbors(serviceAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(serviceAct2Insert.getLocationId(), nextAct.getLocationId())){
-				/**
+				if(hardActivityLevelConstraint.fulfilled(insertionContext, prevAct, serviceAct2Insert, nextAct, prevActDepTime_newVehicle)){
-				 * builds a path on this route forwardPath={i,k,j,j+1,j+2,...,j+nuOfActsForwardLooking}
+					/**
-				 */		
+					 * builds a path on this route forwardPath={i,k,j,j+1,j+2,...,j+nuOfActsForwardLooking}
-				InsertionContext iContext = new InsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, prevActDepTime_newVehicle);
+					 */		
-				ActivityInsertionCosts actInsertionCosts = activityInsertionCostsCalculator.calculate(iContext, prevAct, nextAct, serviceAct2Insert, prevActDepTime_newVehicle);
+					ActivityInsertionCosts actInsertionCosts = activityInsertionCostsCalculator.calculate(insertionContext, prevAct, nextAct, serviceAct2Insert, prevActDepTime_newVehicle);
-				if(actInsertionCosts != null){
+
 					/**
 					 * insertion_cost_approximation = c({0,1,...,i},newVehicle) + c({i,k,j,j+1,j+2,...,j+nuOfActsForwardLooking},newVehicle) - c({0,1,...,i,j,j+1,...,j+nuOfActsForwardLooking},oldVehicle)
 					 */
@@ -190,6 +193,7 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 						bestInsertionsQueue.add(new InsertionData(insertion_cost_approximation, InsertionData.NO_INDEX, actIndex, newVehicle, newDriver));
 					}
 				}
+
 			}
 
 			/**
@@ -221,20 +225,20 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		}
 		End nextAct = end;
 		if(neighborhood.areNeighbors(serviceAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(serviceAct2Insert.getLocationId(), nextAct.getLocationId())){
+			if(hardActivityLevelConstraint.fulfilled(insertionContext, prevAct, serviceAct2Insert, nextAct, prevActDepTime_newVehicle)){
+				ActivityInsertionCosts actInsertionCosts = activityInsertionCostsCalculator.calculate(insertionContext, prevAct, nextAct, serviceAct2Insert, prevActDepTime_newVehicle);
+				if(actInsertionCosts != null){
+					/**
+					 * insertion_cost_approximation = c({0,1,...,i},newVehicle) + c({i,k,j,j+1,j+2,...,j+nuOfActsForwardLooking},newVehicle) - c({0,1,...,i,j,j+1,...,j+nuOfActsForwardLooking},oldVehicle)
+					 */
+					double insertion_cost_approximation = sumOf_prevCosts_newVehicle - sumOf_prevCosts_oldVehicle(currentRoute,prevAct) + actInsertionCosts.getAdditionalCosts(); 
 
-			InsertionContext iContext = new InsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, prevActDepTime_newVehicle);
+					/**
-			ActivityInsertionCosts actInsertionCosts = activityInsertionCostsCalculator.calculate(iContext, prevAct, nextAct, serviceAct2Insert, prevActDepTime_newVehicle);
+					 * memorize it in insertion-queue
-			if(actInsertionCosts != null){
+					 */
-				/**
+					if(insertion_cost_approximation < best_known_insertion_costs){
-				 * insertion_cost_approximation = c({0,1,...,i},newVehicle) + c({i,k,j,j+1,j+2,...,j+nuOfActsForwardLooking},newVehicle) - c({0,1,...,i,j,j+1,...,j+nuOfActsForwardLooking},oldVehicle)
+						bestInsertionsQueue.add(new InsertionData(insertion_cost_approximation, InsertionData.NO_INDEX, actIndex, newVehicle, newDriver));
-				 */
+					}
-				double insertion_cost_approximation = sumOf_prevCosts_newVehicle - sumOf_prevCosts_oldVehicle(currentRoute,prevAct) + actInsertionCosts.getAdditionalCosts(); 
-
-				/**
-				 * memorize it in insertion-queue
-				 */
-				if(insertion_cost_approximation < best_known_insertion_costs){
-					bestInsertionsQueue.add(new InsertionData(insertion_cost_approximation, InsertionData.NO_INDEX, actIndex, newVehicle, newDriver));
 				}
 			}
 		}

jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java

@@ -58,8 +58,8 @@ public class BuildCVRPAlgoFromScratchTest {
 			}
 		};
 
-		ActivityInsertionCostsCalculator marginalCalculus = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), hardActLevelConstraint);
+		ActivityInsertionCostsCalculator marginalCalculus = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts());
-		CalculatesServiceInsertion serviceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), marginalCalculus, new HardLoadConstraint(stateManager));
+		ServiceInsertionCalculator serviceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), marginalCalculus, new HardLoadConstraint(stateManager), hardActLevelConstraint);
 
 		
 		VehicleFleetManager fleetManager = new InfiniteVehicles(vrp.getVehicles());

jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java

@@ -60,10 +60,10 @@ public class BuildPDVRPAlgoFromScratchTest {
 			actLevelConstraintAccumulator.addConstraint(new HardPickupAndDeliveryActivityLevelConstraint(stateManager));
 			actLevelConstraintAccumulator.addConstraint(new HardTimeWindowActivityLevelConstraint(stateManager, vrp.getTransportCosts()));
 			
-			ActivityInsertionCostsCalculator marginalCalculus = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), actLevelConstraintAccumulator);
+			ActivityInsertionCostsCalculator marginalCalculus = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts());
 
 
-			CalculatesServiceInsertion serviceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), marginalCalculus, new HardPickupAndDeliveryLoadConstraint(stateManager));
+			ServiceInsertionCalculator serviceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), marginalCalculus, new HardPickupAndDeliveryLoadConstraint(stateManager), actLevelConstraintAccumulator);
 //			CalculatesServiceInsertion serviceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), marginalCalculus, new HardConstraints.HardLoadConstraint(stateManager));
 			
 			VehicleFleetManager fleetManager = new InfiniteVehicles(vrp.getVehicles());

jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java

@@ -148,7 +148,7 @@ public class GendreauPostOptTest {
 		
 		activityCosts = new ExampleActivityCostFunction();
 		
-		CalculatesServiceInsertion standardServiceInsertion = new CalculatesServiceInsertion(cost, new LocalActivityInsertionCostsCalculator(cost, activityCosts, new HardTimeWindowActivityLevelConstraint(states, cost)), new HardLoadConstraint(states));
+		ServiceInsertionCalculator standardServiceInsertion = new ServiceInsertionCalculator(cost, new LocalActivityInsertionCostsCalculator(cost, activityCosts), new HardLoadConstraint(states), new HardTimeWindowActivityLevelConstraint(states, cost));
 
 		
 		CalculatesServiceInsertionConsideringFixCost withFixCost = new CalculatesServiceInsertionConsideringFixCost(standardServiceInsertion, states);

jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java

@@ -45,7 +45,7 @@ import basics.route.VehicleRoute;
 
 public class TestCalculatesServiceInsertion {
 	
-	CalculatesServiceInsertion serviceInsertion;
+	ServiceInsertionCalculator serviceInsertion;
 	
 	VehicleRoutingTransportCosts costs;
 	
@@ -153,7 +153,7 @@ public class TestCalculatesServiceInsertion {
 		
 		ExampleActivityCostFunction activityCosts = new ExampleActivityCostFunction();
 
-		serviceInsertion = new CalculatesServiceInsertion(costs, new LocalActivityInsertionCostsCalculator(costs, activityCosts, new HardTimeWindowActivityLevelConstraint(states, costs)), new HardLoadConstraint(states));
+		serviceInsertion = new ServiceInsertionCalculator(costs, new LocalActivityInsertionCostsCalculator(costs, activityCosts), new HardLoadConstraint(states), new HardTimeWindowActivityLevelConstraint(states, costs));
 		
 		stateUpdater = new UpdateStates(states, costs, activityCosts);
 		

jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java

@@ -48,7 +48,7 @@ import basics.route.VehicleRoute;
 
 public class TestCalculatesServiceInsertionOnRouteLevel {
 	
-	CalculatesServiceInsertionOnRouteLevel serviceInsertion;
+	ServiceInsertionOnRouteLevelCalculator serviceInsertion;
 	
 	VehicleRoutingTransportCosts costs;
 	
@@ -143,8 +143,8 @@ public class TestCalculatesServiceInsertionOnRouteLevel {
 		states = new StateManagerImpl();
 		
 		ExampleActivityCostFunction activityCosts = new ExampleActivityCostFunction();
-		ActivityInsertionCostsCalculator actInsertionCostCalculator = new RouteLevelActivityInsertionCostsEstimator(costs, activityCosts, new HardTimeWindowActivityLevelConstraint(states, costs), states);
+		ActivityInsertionCostsCalculator actInsertionCostCalculator = new RouteLevelActivityInsertionCostsEstimator(costs, activityCosts, states);
-		serviceInsertion = new CalculatesServiceInsertionOnRouteLevel(costs,activityCosts, new HardLoadConstraint(states), actInsertionCostCalculator);
+		serviceInsertion = new ServiceInsertionOnRouteLevelCalculator(costs,activityCosts, actInsertionCostCalculator, new HardLoadConstraint(states), new HardTimeWindowActivityLevelConstraint(states, costs));
 		serviceInsertion.setNuOfActsForwardLooking(4);
 		serviceInsertion.setStates(states);