added soft constraints

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

@@ -253,7 +253,7 @@ class CalculatorBuilder {
 		}
 
 		ShipmentInsertionCalculator shipmentInsertion = new ShipmentInsertionCalculator(vrp.getTransportCosts(), actInsertionCalc, constraintManager, constraintManager);
-		ServiceInsertionCalculator serviceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), actInsertionCalc, constraintManager, constraintManager);
+		ServiceInsertionCalculator serviceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), constraintManager);
 		
 		JobCalculatorSwitcher switcher = new JobCalculatorSwitcher();
 		switcher.put(Shipment.class, shipmentInsertion);
@@ -263,8 +263,6 @@ class CalculatorBuilder {
 		
 		PenalyzeInsertionCostsWithPenaltyVehicle penalyzeInsertionCosts = new PenalyzeInsertionCostsWithPenaltyVehicle(switcher);
 		
-//		JobInsertionCostsCalculator standardServiceInsertion = new ServiceInsertionCalculator(vrp.getTransportCosts(), actInsertionCalc, constraintManager, constraintManager);
-//		((ServiceInsertionCalculator) standardServiceInsertion).setNeighborhood(vrp.getNeighborhood());
 		CalculatorPlusListeners calcPlusListeners = new CalculatorPlusListeners(penalyzeInsertionCosts);
 		
 		return calcPlusListeners;

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

@@ -16,10 +16,12 @@
  ******************************************************************************/
 package jsprit.core.algorithm.recreate;
 
-import jsprit.core.algorithm.recreate.ActivityInsertionCostsCalculator.ActivityInsertionCosts;
+import jsprit.core.problem.constraint.ConstraintManager;
 import jsprit.core.problem.constraint.HardActivityStateLevelConstraint;
 import jsprit.core.problem.constraint.HardActivityStateLevelConstraint.ConstraintsStatus;
 import jsprit.core.problem.constraint.HardRouteStateLevelConstraint;
+import jsprit.core.problem.constraint.SoftActivityConstraint;
+import jsprit.core.problem.constraint.SoftRouteConstraint;
 import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
 import jsprit.core.problem.driver.Driver;
 import jsprit.core.problem.job.Job;
@@ -34,13 +36,15 @@ import jsprit.core.problem.solution.route.activity.TourActivityFactory;
 import jsprit.core.problem.vehicle.Vehicle;
 import jsprit.core.problem.vehicle.VehicleImpl.NoVehicle;
 import jsprit.core.util.CalculationUtils;
-import jsprit.core.util.Neighborhood;
 
 import org.apache.log4j.Logger;
 
-
-
-
+/**
+ * Calculator that calculates the best insertion position for a {@link Service}.
+ * 
+ * @author schroeder
+ *
+ */
 final class ServiceInsertionCalculator implements JobInsertionCostsCalculator{
 
 	private static final Logger logger = Logger.getLogger(ServiceInsertionCalculator.class);
@@ -49,32 +53,21 @@ final class ServiceInsertionCalculator implements JobInsertionCostsCalculator{
 	
 	private HardActivityStateLevelConstraint hardActivityLevelConstraint;
 	
-	private Neighborhood neighborhood = new Neighborhood() {
-		
-		@Override
-		public boolean areNeighbors(String location1, String location2) {
-			return true;
-		}
-	};
+	private SoftRouteConstraint softRouteConstraint;
 	
-	private ActivityInsertionCostsCalculator activityInsertionCostsCalculator;
+	private SoftActivityConstraint softActivityConstraint;
 	
 	private VehicleRoutingTransportCosts transportCosts;
 	
 	private TourActivityFactory activityFactory;
-	
-	public void setNeighborhood(Neighborhood neighborhood) {
-		this.neighborhood = neighborhood;
-		logger.info("initialise neighborhood " + neighborhood);
-	}
-	
 
-	public ServiceInsertionCalculator(VehicleRoutingTransportCosts routingCosts, ActivityInsertionCostsCalculator activityInsertionCostsCalculator, HardRouteStateLevelConstraint hardRouteLevelConstraint, HardActivityStateLevelConstraint hardActivityLevelConstraint) {
+	public ServiceInsertionCalculator(VehicleRoutingTransportCosts routingCosts, ConstraintManager constraintManager) {
 		super();
-		this.activityInsertionCostsCalculator = activityInsertionCostsCalculator;
-		this.hardRouteLevelConstraint = hardRouteLevelConstraint;
-		this.hardActivityLevelConstraint = hardActivityLevelConstraint;
 		this.transportCosts = routingCosts;
+		hardRouteLevelConstraint = constraintManager;
+		hardActivityLevelConstraint = constraintManager;
+		softActivityConstraint = constraintManager;
+		softRouteConstraint = constraintManager;
 		activityFactory = new DefaultTourActivityFactory();
 		logger.info("initialise " + this);
 	}
@@ -100,7 +93,10 @@ final class ServiceInsertionCalculator implements JobInsertionCostsCalculator{
 		}
 		
 		double bestCost = bestKnownCosts;
-		ActivityInsertionCosts bestMarginals = null;
+		
+		//from job2insert induced costs at route level
+		double routeICosts = softRouteConstraint.getCosts(insertionContext);
+		
 		Service service = (Service)jobToInsert;
 		int insertionIndex = InsertionData.NO_INDEX;
 		
@@ -115,21 +111,19 @@ final class ServiceInsertionCalculator implements JobInsertionCostsCalculator{
 		int actIndex = 0;
 		boolean loopBroken = false;
 		for(TourActivity nextAct : currentRoute.getTourActivities().getActivities()){
-			if(neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), nextAct.getLocationId())){
-				ConstraintsStatus status = hardActivityLevelConstraint.fulfilled(insertionContext, prevAct, deliveryAct2Insert, nextAct, prevActStartTime);
-				if(status.equals(ConstraintsStatus.FULFILLED)){
-					ActivityInsertionCosts mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
-					if(mc.getAdditionalCosts() < bestCost){
-						bestCost = mc.getAdditionalCosts();
-						bestMarginals = mc;
-						insertionIndex = actIndex;
-					}
-				}
-				else if(status.equals(ConstraintsStatus.NOT_FULFILLED_BREAK)){
-					loopBroken = true;
-					break;
+			ConstraintsStatus status = hardActivityLevelConstraint.fulfilled(insertionContext, prevAct, deliveryAct2Insert, nextAct, prevActStartTime);
+			if(status.equals(ConstraintsStatus.FULFILLED)){
+				//from job2insert induced costs at activity level
+				double activityICosts = softActivityConstraint.getCosts(insertionContext, prevAct, deliveryAct2Insert, nextAct, prevActStartTime);
+				if(routeICosts + activityICosts < bestCost){
+					bestCost = routeICosts + activityICosts;
+					insertionIndex = actIndex;
 				}
 			}
+			else if(status.equals(ConstraintsStatus.NOT_FULFILLED_BREAK)){
+				loopBroken = true;
+				break;
+			}
 			double nextActArrTime = prevActStartTime + transportCosts.getTransportTime(prevAct.getLocationId(), nextAct.getLocationId(), prevActStartTime, newDriver, newVehicle);
 			double nextActEndTime = CalculationUtils.getActivityEndTime(nextActArrTime, nextAct);
 			prevActStartTime = nextActEndTime;
@@ -138,29 +132,21 @@ final class ServiceInsertionCalculator implements JobInsertionCostsCalculator{
 		}
 		End nextAct = end;
 		if(!loopBroken){
-			if(neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), nextAct.getLocationId())){
-				ConstraintsStatus status = hardActivityLevelConstraint.fulfilled(insertionContext, prevAct, deliveryAct2Insert, nextAct, prevActStartTime); 
-				if(status.equals(ConstraintsStatus.FULFILLED)){
-					ActivityInsertionCosts mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
-					if(mc.getAdditionalCosts() < bestCost){
-						bestCost = mc.getAdditionalCosts();
-						bestMarginals = mc;
-						insertionIndex = actIndex;
-					}
+			ConstraintsStatus status = hardActivityLevelConstraint.fulfilled(insertionContext, prevAct, deliveryAct2Insert, nextAct, prevActStartTime); 
+			if(status.equals(ConstraintsStatus.FULFILLED)){
+				double activityICosts = softActivityConstraint.getCosts(insertionContext, prevAct, deliveryAct2Insert, nextAct, prevActStartTime);
+				if(routeICosts + activityICosts < bestCost){
+					bestCost = routeICosts + activityICosts;
+					insertionIndex = actIndex;
 				}
 			}
 		}
-
 		if(insertionIndex == InsertionData.NO_INDEX) {
 			return InsertionData.createEmptyInsertionData();
 		}
 		InsertionData insertionData = new InsertionData(bestCost, InsertionData.NO_INDEX, insertionIndex, newVehicle, newDriver);
 		insertionData.setVehicleDepartureTime(newVehicleDepartureTime);
-		insertionData.setAdditionalTime(bestMarginals.getAdditionalTime());
 		return insertionData;
 	}
 
-	public ActivityInsertionCosts calculate(JobInsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double departureTimeAtPrevAct) {	
-		return activityInsertionCostsCalculator.getCosts(iFacts, prevAct, nextAct, newAct, departureTimeAtPrevAct);		
-	}
 }

jsprit-core/src/main/java/jsprit/core/problem/constraint/AdditionalTransportationCosts.java

@@ -0,0 +1,70 @@
+package jsprit.core.problem.constraint;
+
+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.util.CalculationUtils;
+
+/**
+ * Calculates additional transportation costs induced by inserting newAct.
+ * 
+ * @author schroeder
+ *
+ */
+public class AdditionalTransportationCosts implements SoftActivityConstraint{
+
+	private VehicleRoutingTransportCosts routingCosts;
+	
+	/**
+	 * Constructs the calculator that calculates additional transportation costs induced by inserting new activity.
+	 *
+	 * <p>It is calculated at local level, i.e. the additional costs of inserting act_new between act_i and act_j is c(act_i,act_new,newVehicle)+c(act_new,act_j,newVehicle)-c(act_i,act_j,oldVehicle)
+	 * <p>If newVehicle.isReturnToDepot == false then the additional costs of inserting act_new between act_i and end is c(act_i,act_new) [since act_new is then the new end-of-route]
+	 *
+	 * @param routingCosts
+	 */
+	public AdditionalTransportationCosts(VehicleRoutingTransportCosts routingCosts) {
+		super();
+		this.routingCosts = routingCosts;
+	}
+
+	/**
+	 * Returns additional transportation costs induced by inserting newAct.
+	 * 
+	 * <p>It is calculated at local level, i.e. the additional costs of inserting act_new between act_i and act_j is c(act_i,act_new,newVehicle)+c(act_new,act_j,newVehicle)-c(act_i,act_j,oldVehicle)
+	 * <p>If newVehicle.isReturnToDepot == false then the additional costs of inserting act_new between act_i and end is c(act_i,act_new) [since act_new is then the new end-of-route]
+	 */
+	@Override
+	public double getCosts(JobInsertionContext iFacts, TourActivity prevAct,TourActivity newAct, TourActivity nextAct, double depTimeAtPrevAct) {
+		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());
+		
+		double newAct_arrTime = depTimeAtPrevAct + tp_time_prevAct_newAct;
+		double newAct_endTime = CalculationUtils.getActivityEndTime(newAct_arrTime, newAct);
+		
+		//open routes
+		if(nextAct instanceof End){
+			if(!iFacts.getNewVehicle().isReturnToDepot()){
+				return tp_costs_prevAct_newAct;
+			}
+		}
+		
+		double tp_costs_newAct_nextAct = routingCosts.getTransportCost(newAct.getLocationId(), nextAct.getLocationId(), newAct_endTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
+		double totalCosts = tp_costs_prevAct_newAct + tp_costs_newAct_nextAct; 
+		
+		double oldCosts;
+		if(iFacts.getRoute().isEmpty()){
+			double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocationId(), nextAct.getLocationId(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
+			oldCosts = tp_costs_prevAct_nextAct;
+		}
+		else{
+			double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocationId(), nextAct.getLocationId(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle());
+			oldCosts = tp_costs_prevAct_nextAct;
+		}
+		
+		double additionalCosts = totalCosts - oldCosts;
+		return additionalCosts;
+	}
+
+}

jsprit-core/src/main/java/jsprit/core/problem/constraint/ConstraintManager.java

@@ -14,7 +14,7 @@ import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter;
 import org.apache.log4j.Logger;
 
 @SuppressWarnings("deprecation")
-public class ConstraintManager implements HardActivityStateLevelConstraint, HardRouteStateLevelConstraint{
+public class ConstraintManager implements HardActivityStateLevelConstraint, HardRouteStateLevelConstraint, SoftActivityConstraint, SoftRouteConstraint{
 
 	public static enum Priority {
 		CRITICAL, HIGH, LOW
@@ -26,6 +26,10 @@ public class ConstraintManager implements HardActivityStateLevelConstraint, Hard
 	
 	private HardRouteLevelConstraintManager routeLevelConstraintManager = new HardRouteLevelConstraintManager();
 	
+	private SoftActivityConstraintManager softActivityConstraintManager = new SoftActivityConstraintManager();
+	
+	private SoftRouteConstraintManager softRouteConstraintManager = new SoftRouteConstraintManager();
+	
 	private VehicleRoutingProblem vrp;
 	
 	private RouteAndActivityStateGetter stateManager;
@@ -56,6 +60,14 @@ public class ConstraintManager implements HardActivityStateLevelConstraint, Hard
 				routeLevelConstraintManager.addConstraint((HardRouteStateLevelConstraint) c);
 				constraintTypeKnown = true;
 			}
+			if(c instanceof SoftRouteConstraint){
+				softRouteConstraintManager.addConstraint((SoftRouteConstraint)c);
+				constraintTypeKnown = true;
+			}
+			if(c instanceof SoftActivityConstraint){
+				softActivityConstraintManager.addConstraint((SoftActivityConstraint)c);
+				constraintTypeKnown = true;
+			}
 			if(!constraintTypeKnown){
 				log.warn("constraint " + c + " unknown thus ignores the constraint. currently, a constraint must implement either HardActivityStateLevelConstraint or HardRouteStateLevelConstraint");
 			}
@@ -82,6 +94,8 @@ public class ConstraintManager implements HardActivityStateLevelConstraint, Hard
 		}
 	}
 	
+//	public void add
+	
 	public void addConstraint(HardActivityStateLevelConstraint actLevelConstraint, Priority priority){
 		actLevelConstraintManager.addConstraint(actLevelConstraint,priority);
 	}
@@ -90,6 +104,14 @@ public class ConstraintManager implements HardActivityStateLevelConstraint, Hard
 		routeLevelConstraintManager.addConstraint(routeLevelConstraint);
 	}
 	
+	public void addConstraint(SoftActivityConstraint softActivityConstraint){
+		softActivityConstraintManager.addConstraint(softActivityConstraint);
+	}
+	
+	public void addConstraint(SoftRouteConstraint softRouteConstraint){
+		softRouteConstraintManager.addConstraint(softRouteConstraint);
+	}
+	
 	@Override
 	public boolean fulfilled(JobInsertionContext insertionContext) {
 		return routeLevelConstraintManager.fulfilled(insertionContext);
@@ -104,7 +126,19 @@ public class ConstraintManager implements HardActivityStateLevelConstraint, Hard
 		List<jsprit.core.problem.constraint.Constraint> constraints = new ArrayList<jsprit.core.problem.constraint.Constraint>();
 		constraints.addAll(actLevelConstraintManager.getAllConstraints());
 		constraints.addAll(routeLevelConstraintManager.getConstraints());
+		constraints.addAll(softActivityConstraintManager.getConstraints());
+		constraints.addAll(softRouteConstraintManager.getConstraints());
 		return Collections.unmodifiableCollection(constraints);
 	}
+
+	@Override
+	public double getCosts(JobInsertionContext insertionContext) {
+		return softRouteConstraintManager.getCosts(insertionContext);
+	}
+
+	@Override
+	public double getCosts(JobInsertionContext iFacts, TourActivity prevAct,TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
+		return softActivityConstraintManager.getCosts(iFacts, prevAct, newAct, nextAct, prevActDepTime);
+	}
 	
 }

jsprit-core/src/main/java/jsprit/core/problem/constraint/SoftActivityConstraint.java

@@ -0,0 +1,10 @@
+package jsprit.core.problem.constraint;
+
+import jsprit.core.problem.misc.JobInsertionContext;
+import jsprit.core.problem.solution.route.activity.TourActivity;
+
+public interface SoftActivityConstraint extends SoftConstraint{
+
+	public double getCosts(JobInsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime);
+	
+}

jsprit-core/src/main/java/jsprit/core/problem/constraint/SoftActivityConstraintManager.java

@@ -0,0 +1,29 @@
+package jsprit.core.problem.constraint;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+
+import jsprit.core.problem.misc.JobInsertionContext;
+import jsprit.core.problem.solution.route.activity.TourActivity;
+
+class SoftActivityConstraintManager implements SoftActivityConstraint{
+
+	private Collection<SoftActivityConstraint> softConstraints = new ArrayList<SoftActivityConstraint>();
+	
+	public void addConstraint(SoftActivityConstraint constraint){
+		softConstraints.add(constraint);
+	}
+	
+	Collection<SoftActivityConstraint> getConstraints(){ return Collections.unmodifiableCollection(softConstraints); }
+	
+	@Override
+	public double getCosts(JobInsertionContext iFacts, TourActivity prevAct,TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
+		double sumCosts = 0.0;
+		for(SoftActivityConstraint c : softConstraints){
+			sumCosts += c.getCosts(iFacts, prevAct, newAct, nextAct, prevActDepTime);
+		}
+		return sumCosts;
+	}
+
+}

jsprit-core/src/main/java/jsprit/core/problem/constraint/SoftRouteConstraint.java

@@ -0,0 +1,9 @@
+package jsprit.core.problem.constraint;
+
+import jsprit.core.problem.misc.JobInsertionContext;
+
+public interface SoftRouteConstraint extends SoftConstraint{
+	
+	public double getCosts(JobInsertionContext insertionContext);
+
+}

jsprit-core/src/main/java/jsprit/core/problem/constraint/SoftRouteConstraintManager.java

@@ -0,0 +1,28 @@
+package jsprit.core.problem.constraint;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+
+import jsprit.core.problem.misc.JobInsertionContext;
+
+class SoftRouteConstraintManager implements SoftRouteConstraint{
+
+	private Collection<SoftRouteConstraint> softConstraints = new ArrayList<SoftRouteConstraint>();
+	
+	public void addConstraint(SoftRouteConstraint constraint){
+		softConstraints.add(constraint);
+	}
+	
+	Collection<SoftRouteConstraint> getConstraints(){ return Collections.unmodifiableCollection(softConstraints); }
+	
+	@Override
+	public double getCosts(JobInsertionContext insertionContext) {
+		double sumCosts = 0.0;
+		for(SoftRouteConstraint c : softConstraints){
+			sumCosts += c.getCosts(insertionContext);
+		}
+		return sumCosts;
+	}
+
+}