diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/box/Jsprit.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/box/Jsprit.java index 14e33fd3..92386314 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/box/Jsprit.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/box/Jsprit.java @@ -526,8 +526,8 @@ public class Jsprit { boolean fastRegret = Boolean.parseBoolean(getProperty(Parameter.FAST_REGRET.toString())); if (es != null) { if(fastRegret){ - RegretInsertionConcurrentFast regretInsertion = (RegretInsertionConcurrentFast) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) - .setInsertionStrategy(InsertionBuilder.Strategy.REGRET) + RegretInsertionConcurrentFast regretInsertion = (RegretInsertionConcurrentFast) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) + .setInsertionStrategy(InsertionStrategyBuilder.Strategy.REGRET) .setConcurrentMode(es, noThreads) .setFastRegret(true) .considerFixedCosts(toDouble(getProperty(Parameter.FIXED_COST_PARAM.toString()))) @@ -540,8 +540,8 @@ public class Jsprit { regret = regretInsertion; } else { - RegretInsertionConcurrent regretInsertion = (RegretInsertionConcurrent) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) - .setInsertionStrategy(InsertionBuilder.Strategy.REGRET) + RegretInsertionConcurrent regretInsertion = (RegretInsertionConcurrent) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) + .setInsertionStrategy(InsertionStrategyBuilder.Strategy.REGRET) .setConcurrentMode(es, noThreads) .considerFixedCosts(toDouble(getProperty(Parameter.FIXED_COST_PARAM.toString()))) .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString()))) @@ -553,8 +553,8 @@ public class Jsprit { } } else { if(fastRegret) { - RegretInsertionFast regretInsertion = (RegretInsertionFast) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) - .setInsertionStrategy(InsertionBuilder.Strategy.REGRET) + RegretInsertionFast regretInsertion = (RegretInsertionFast) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) + .setInsertionStrategy(InsertionStrategyBuilder.Strategy.REGRET) .setFastRegret(true) .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString()))) .considerFixedCosts(toDouble(getProperty(Parameter.FIXED_COST_PARAM.toString()))) @@ -566,8 +566,8 @@ public class Jsprit { regret = regretInsertion; } else{ - RegretInsertion regretInsertion = (RegretInsertion) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) - .setInsertionStrategy(InsertionBuilder.Strategy.REGRET) + RegretInsertion regretInsertion = (RegretInsertion) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) + .setInsertionStrategy(InsertionStrategyBuilder.Strategy.REGRET) .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString()))) .considerFixedCosts(toDouble(getProperty(Parameter.FIXED_COST_PARAM.toString()))) .setActivityInsertionCostCalculator(activityInsertion) @@ -581,16 +581,16 @@ public class Jsprit { AbstractInsertionStrategy best; if (vrp.getJobs().size() < 250 || es == null) { - BestInsertion bestInsertion = (BestInsertion) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) - .setInsertionStrategy(InsertionBuilder.Strategy.BEST) + BestInsertion bestInsertion = (BestInsertion) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) + .setInsertionStrategy(InsertionStrategyBuilder.Strategy.BEST) .considerFixedCosts(Double.valueOf(properties.getProperty(Parameter.FIXED_COST_PARAM.toString()))) .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString()))) .setActivityInsertionCostCalculator(activityInsertion) .build(); best = bestInsertion; } else { - BestInsertionConcurrent bestInsertion = (BestInsertionConcurrent) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) - .setInsertionStrategy(InsertionBuilder.Strategy.BEST) + BestInsertionConcurrent bestInsertion = (BestInsertionConcurrent) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager) + .setInsertionStrategy(InsertionStrategyBuilder.Strategy.BEST) .considerFixedCosts(Double.valueOf(properties.getProperty(Parameter.FIXED_COST_PARAM.toString()))) .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString()))) .setConcurrentMode(es, noThreads) diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/recreate/InsertionBuilder.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/recreate/InsertionBuilder.java index 98e30be4..3a30411a 100644 --- a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/recreate/InsertionBuilder.java +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/recreate/InsertionBuilder.java @@ -28,7 +28,10 @@ import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutorService; - +/** + * use InsertionStrategyBuilder instead + */ +@Deprecated public class InsertionBuilder { private boolean fastRegret; diff --git a/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/recreate/InsertionStrategyBuilder.java b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/recreate/InsertionStrategyBuilder.java new file mode 100644 index 00000000..5ad9deb3 --- /dev/null +++ b/jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/recreate/InsertionStrategyBuilder.java @@ -0,0 +1,212 @@ +/* + * Licensed to GraphHopper GmbH under one or more contributor + * license agreements. See the NOTICE file distributed with this work for + * additional information regarding copyright ownership. + * + * GraphHopper GmbH licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.graphhopper.jsprit.core.algorithm.recreate; + +import com.graphhopper.jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners; +import com.graphhopper.jsprit.core.algorithm.recreate.listener.InsertionListener; +import com.graphhopper.jsprit.core.algorithm.state.StateManager; +import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem; +import com.graphhopper.jsprit.core.problem.constraint.ConstraintManager; +import com.graphhopper.jsprit.core.problem.vehicle.VehicleFleetManager; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.ExecutorService; + + +public class InsertionStrategyBuilder { + + private boolean fastRegret; + + + public enum Strategy { + REGRET, BEST + } + + private VehicleRoutingProblem vrp; + + private StateManager stateManager; + + private boolean local = true; + + private ConstraintManager constraintManager; + + private VehicleFleetManager fleetManager; + + private double weightOfFixedCosts; + + private boolean considerFixedCosts = false; + + private ActivityInsertionCostsCalculator actInsertionCostsCalculator = null; + + private int forwaredLooking; + + private int memory; + + private ExecutorService executor; + + private int nuOfThreads; + + private double timeSlice; + + private int nNeighbors; + + private boolean timeScheduling = false; + + private boolean allowVehicleSwitch = true; + + private boolean addDefaultCostCalc = true; + + private Strategy strategy = Strategy.BEST; + + private boolean isFastRegret = false; + + public InsertionStrategyBuilder(VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, StateManager stateManager, ConstraintManager constraintManager) { + super(); + this.vrp = vrp; + this.stateManager = stateManager; + this.constraintManager = constraintManager; + this.fleetManager = vehicleFleetManager; + } + + public InsertionStrategyBuilder setInsertionStrategy(Strategy strategy) { + this.strategy = strategy; + return this; + } + + public InsertionStrategyBuilder setRouteLevel(int forwardLooking, int memory) { + local = false; + this.forwaredLooking = forwardLooking; + this.memory = memory; + return this; + } + + public InsertionStrategyBuilder setRouteLevel(int forwardLooking, int memory, boolean addDefaultMarginalCostCalculation) { + local = false; + this.forwaredLooking = forwardLooking; + this.memory = memory; + this.addDefaultCostCalc = addDefaultMarginalCostCalculation; + return this; + } + + public InsertionStrategyBuilder setFastRegret(boolean fastRegret) { + this.isFastRegret = fastRegret; + return this; + } + + + public InsertionStrategyBuilder setLocalLevel() { + local = true; + return this; + } + + /** + * If addDefaulMarginalCostCalculation is false, no calculator is set which implicitly assumes that marginal cost calculation + * is controlled by your custom soft constraints. + * + * @param addDefaultMarginalCostCalculation + * @return + */ + public InsertionStrategyBuilder setLocalLevel(boolean addDefaultMarginalCostCalculation) { + local = true; + addDefaultCostCalc = addDefaultMarginalCostCalculation; + return this; + } + + public InsertionStrategyBuilder considerFixedCosts(double weightOfFixedCosts) { + this.weightOfFixedCosts = weightOfFixedCosts; + this.considerFixedCosts = true; + return this; + } + + public InsertionStrategyBuilder setActivityInsertionCostCalculator(ActivityInsertionCostsCalculator activityInsertionCostsCalculator) { + this.actInsertionCostsCalculator = activityInsertionCostsCalculator; + return this; + } + + public InsertionStrategyBuilder setConcurrentMode(ExecutorService executor, int nuOfThreads) { + this.executor = executor; + this.nuOfThreads = nuOfThreads; + return this; + } + + + public InsertionStrategy build() { + List iListeners = new ArrayList(); + List algorithmListeners = new ArrayList(); + JobInsertionCostsCalculatorBuilder calcBuilder = new JobInsertionCostsCalculatorBuilder(iListeners, algorithmListeners); + if (local) { + calcBuilder.setLocalLevel(addDefaultCostCalc); + } else { + calcBuilder.setRouteLevel(forwaredLooking, memory, addDefaultCostCalc); + } + calcBuilder.setConstraintManager(constraintManager); + calcBuilder.setStateManager(stateManager); + calcBuilder.setVehicleRoutingProblem(vrp); + calcBuilder.setVehicleFleetManager(fleetManager); + calcBuilder.setActivityInsertionCostsCalculator(actInsertionCostsCalculator); + if (considerFixedCosts) { + calcBuilder.considerFixedCosts(weightOfFixedCosts); + } + if (timeScheduling) { + calcBuilder.experimentalTimeScheduler(timeSlice, nNeighbors); + } + calcBuilder.setAllowVehicleSwitch(allowVehicleSwitch); + JobInsertionCostsCalculator costCalculator = calcBuilder.build(); + + InsertionStrategy insertion; + if (strategy.equals(Strategy.BEST)) { + if (executor == null) { + insertion = new BestInsertion(costCalculator, vrp); + } else { + insertion = new BestInsertionConcurrent(costCalculator, executor, nuOfThreads, vrp); + } + } else if (strategy.equals(Strategy.REGRET)) { + if (executor == null) { + if (isFastRegret) { + RegretInsertionFast regret = new RegretInsertionFast(costCalculator, vrp, fleetManager); + regret.setSwitchAllowed(allowVehicleSwitch); + insertion = regret; + } else { + RegretInsertion regret = new RegretInsertion(costCalculator, vrp); + insertion = regret; + } + + } else { + if (isFastRegret) { + RegretInsertionConcurrentFast regret = new RegretInsertionConcurrentFast(costCalculator, vrp, executor, fleetManager); + regret.setSwitchAllowed(allowVehicleSwitch); + insertion = regret; + } else { + RegretInsertionConcurrent regret = new RegretInsertionConcurrent(costCalculator, vrp, executor); + insertion = regret; + } + + } + } else throw new IllegalStateException("you should never get here"); + for (InsertionListener l : iListeners) insertion.addListener(l); + return insertion; + } + + public InsertionStrategyBuilder setAllowVehicleSwitch(boolean allowVehicleSwitch) { + this.allowVehicleSwitch = allowVehicleSwitch; + return this; + } + + +}