Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/DistanceCalcualtors/VRPDistanceCalculator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/DistanceCalcualtors/VRPDistanceCalculator.cs	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/DistanceCalcualtors/VRPDistanceCalculator.cs	(revision 9750)
@@ -10,4 +10,5 @@
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Problems.VehicleRouting;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Analysis.FitnessLandscape.DistanceCalculators.VRP {
@@ -61,11 +62,11 @@
     private HashSet<Point> GetEdgeSet(IVRPEncoding vrpSolution) {
       HashSet<Point> edges = new HashSet<Point>();
-      foreach (var tour in vrpSolution.GetTours(null)) {
-        if (tour.Cities.Count > 0) {
-          edges.Add(CreateUndirectedEdge(0, tour.Cities[0]));
-          for (int i = 0; i < tour.Cities.Count - 1; i++) {
-            edges.Add(CreateUndirectedEdge(tour.Cities[i], tour.Cities[i + 1]));
+      foreach (var tour in vrpSolution.GetTours()) {
+        if (tour.Stops.Count > 0) {
+          edges.Add(CreateUndirectedEdge(0, tour.Stops[0]));
+          for (int i = 0; i < tour.Stops.Count - 1; i++) {
+            edges.Add(CreateUndirectedEdge(tour.Stops[i], tour.Stops[i + 1]));
           }
-          edges.Add(CreateUndirectedEdge(tour.Cities.Last(), 0));
+          edges.Add(CreateUndirectedEdge(tour.Stops.Last(), 0));
         }
       }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/HeuristicLab.Analysis.FitnessLandscape.VRP.csproj
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/HeuristicLab.Analysis.FitnessLandscape.VRP.csproj	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/HeuristicLab.Analysis.FitnessLandscape.VRP.csproj	(revision 9750)
@@ -123,6 +123,6 @@
     </Reference>
     <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=x86" />
-    <Reference Include="HeuristicLab.Problems.VehicleRouting-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.VehicleRouting-3.3.dll</HintPath>
+    <Reference Include="HeuristicLab.Problems.VehicleRouting-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.VehicleRouting-3.4.dll</HintPath>
     </Reference>
     <Reference Include="System" />
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/HeuristicLabAnalysisFitnessLandscapeVRPPlugin.cs.frame
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/HeuristicLabAnalysisFitnessLandscapeVRPPlugin.cs.frame	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/HeuristicLabAnalysisFitnessLandscapeVRPPlugin.cs.frame	(revision 9750)
@@ -36,5 +36,5 @@
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]  
-  [PluginDependency("HeuristicLab.Problems.VehicleRouting", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.VehicleRouting", "3.4")]
   public class HeuristicLabAnalysisFitnessLandscapeVRPPlugin : PluginBase { }
 }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/ExchangeManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/ExchangeManipulator.cs	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/ExchangeManipulator.cs	(revision 9750)
@@ -29,4 +29,5 @@
 using HeuristicLab.Problems.VehicleRouting.Encodings;
 using HeuristicLab.Problems.VehicleRouting;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Analysis.FitnessLandscape.VRP {
@@ -46,14 +47,5 @@
     }
 
-    private static bool RouteFeasible(Tour tour, DoubleArray demand, DoubleValue capacity) {
-      double routeLoad = 0;
-      for (int i = 0; i < tour.Cities.Count; i++) {
-        routeLoad += demand[tour.Cities[i]];
-      }
-
-      return routeLoad <= capacity.Value;
-    }
-
-    public static void Apply(IRandom random, PotvinEncoding individual, DoubleArray demand, DoubleValue capacity, bool allowInfeasible) {
+    public static void Apply(IRandom random, PotvinEncoding individual, IVRPProblemInstance problemInstance, bool allowInfeasible) {
       bool feasible;
 
@@ -70,47 +62,41 @@
           Tour tour2 = individual.Tours[tour2Idx];
 
-          int index1 = random.Next(tour1.Cities.Count);
-          int city1 = tour1.Cities[index1];
+          int index1 = random.Next(tour1.Stops.Count);
+          int city1 = tour1.Stops[index1];
 
-          int index2 = random.Next(tour2.Cities.Count);
-          int city2 = tour2.Cities[index2];
+          int index2 = random.Next(tour2.Stops.Count);
+          int city2 = tour2.Stops[index2];
 
           if (!allowInfeasible) {
-            bool originalFeasible =
-              RouteFeasible(tour1, demand, capacity) &&
-              RouteFeasible(tour2, demand, capacity);
+            bool originalFeasible = problemInstance.TourFeasible(tour1, individual) &&
+                                    problemInstance.TourFeasible(tour2, individual);
 
             if (originalFeasible) {
-              double routeLoad = 0;
-              for (int i = 0; i < tour1.Cities.Count; i++) {
-                if (i != index1)
-                  routeLoad += demand[tour1.Cities[i]];
+              var tmpCity1 = tour1.Stops[index1];
+              tour1.Stops.RemoveAt(index1);
+              tour1.Stops.Insert(index1, city2);
+
+              if (problemInstance.TourFeasible(tour1, individual)) {
+                var tmpCity2 = tour2.Stops[index2];
+                tour2.Stops.RemoveAt(index2);
+                tour2.Stops.Insert(index2, city1);
+
+                feasible = problemInstance.TourFeasible(tour2, individual);
+
+                if (!feasible) {
+                  // undo tour1 and tour2 changes
+                  tour2.Stops.RemoveAt(index2);
+                  tour2.Stops.Insert(index2, tmpCity2);
+
+                  tour1.Stops.RemoveAt(index1);
+                  tour1.Stops.Insert(index1, tmpCity1);
+                }
+              } else {
+                feasible = false;
+                // undo tour1 change
+                tour1.Stops.RemoveAt(index1);
+                tour1.Stops.Insert(index1, tmpCity1);
               }
-              routeLoad += demand[city2];
-
-              if (routeLoad > capacity.Value) {
-                feasible = false;
-              } else {
-                routeLoad = 0;
-                for (int i = 0; i < tour2.Cities.Count; i++) {
-                  if (i != index2)
-                    routeLoad += demand[tour2.Cities[i]];
-                }
-                routeLoad += demand[city1];
-
-                if (routeLoad > capacity.Value) {
-                  feasible = false;
-                }
-              }
-
-            }
-          }
-
-          if (feasible) {
-            tour1.Cities.RemoveAt(index1);
-            tour1.Cities.Insert(index1, city2);
-
-            tour2.Cities.RemoveAt(index2);
-            tour2.Cities.Insert(index2, city1);
+            } else feasible = false;
           }
         }
@@ -119,12 +105,6 @@
 
     protected override void Manipulate(IRandom random, PotvinEncoding individual) {
-      BoolValue useDistanceMatrix = UseDistanceMatrixParameter.ActualValue;
-      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
-      DistanceMatrix distMatrix = VRPUtilities.GetDistanceMatrix(coordinates, DistanceMatrixParameter, useDistanceMatrix);
-      DoubleArray demand = DemandParameter.ActualValue;
-      DoubleValue capacity = CapacityParameter.ActualValue;
-
       bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
-      Apply(random, individual, demand, capacity, allowInfeasible);
+      Apply(random, individual, ProblemInstance, allowInfeasible);
     }
   }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/OrOptManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/OrOptManipulator.cs	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/OrOptManipulator.cs	(revision 9750)
@@ -48,5 +48,5 @@
 
     public static void Apply(IRandom random, PotvinEncoding individual) {
-      List<Tour> tours = individual.Tours.FindAll(t => t.Cities.Count >= 2);
+      List<Tour> tours = individual.Tours.FindAll(t => t.Stops.Count >= 2);
 
       if (tours.Count > 0) {
@@ -54,23 +54,23 @@
         Tour tour = tours[tourIdx];
 
-        int segmentStart = random.Next(tour.Cities.Count);
+        int segmentStart = random.Next(tour.Stops.Count);
         int segmentLength;
         if (segmentStart == 0) {
-          segmentLength = 1 + random.Next(tour.Cities.Count - 1);
+          segmentLength = 1 + random.Next(tour.Stops.Count - 1);
         } else {
-          segmentLength = 1 + random.Next(tour.Cities.Count - segmentStart);
+          segmentLength = 1 + random.Next(tour.Stops.Count - segmentStart);
         }
 
-        List<int> segment = tour.Cities.GetRange(segmentStart, segmentLength);
-        tour.Cities.RemoveRange(segmentStart, segmentLength);
+        List<int> segment = tour.Stops.GetRange(segmentStart, segmentLength);
+        tour.Stops.RemoveRange(segmentStart, segmentLength);
         int newPos;
-        if(tour.Cities.Count == 1)
+        if (tour.Stops.Count == 1)
           newPos = 0;
         else
-          newPos = random.Next(tour.Cities.Count - 1);
+          newPos = random.Next(tour.Stops.Count - 1);
 
         if (newPos >= segmentStart)
           newPos++;
-        tour.Cities.InsertRange(newPos, segment);
+        tour.Stops.InsertRange(newPos, segment);
       }
     }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/RelocateManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/RelocateManipulator.cs	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/RelocateManipulator.cs	(revision 9750)
@@ -29,4 +29,5 @@
 using HeuristicLab.Problems.VehicleRouting.Encodings;
 using HeuristicLab.Problems.VehicleRouting;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Analysis.FitnessLandscape.VRP {
@@ -46,14 +47,5 @@
     }
 
-    private static bool RouteFeasible(Tour tour, DoubleArray demand, DoubleValue capacity) {
-      double routeLoad = 0;
-      for (int i = 0; i < tour.Cities.Count; i++) {
-        routeLoad += demand[tour.Cities[i]];
-      }
-
-      return routeLoad <= capacity.Value;
-    }
-
-    public static void Apply(IRandom random, PotvinEncoding individual, DoubleArray demand, DoubleValue capacity, bool allowInfeasible) {
+    public static void Apply(IRandom random, PotvinEncoding individual, IVRPProblemInstance problemInstance, bool allowInfeasible) {
       bool feasible;
 
@@ -63,5 +55,5 @@
         int cities = individual.Cities;
         int city = 1 + random.Next(cities);
-        Tour originalTour = individual.Tours.Find(t => t.Cities.Contains(city));
+        Tour originalTour = individual.Tours.Find(t => t.Stops.Contains(city));
         //consider creating new route
         individual.Tours.Add(new Tour());
@@ -72,12 +64,12 @@
         }
 
-        int originalPosition = originalTour.Cities.IndexOf(city);
-        originalTour.Cities.RemoveAt(originalPosition);
+        int originalPosition = originalTour.Stops.IndexOf(city);
+        originalTour.Stops.RemoveAt(originalPosition);
 
         Tour insertionTour;
         int insertionPosition;
         if (position <= cities) {
-          insertionTour = individual.Tours.Find(t => t.Cities.Contains(position));
-          insertionPosition = insertionTour.Cities.IndexOf(position) + 1;
+          insertionTour = individual.Tours.Find(t => t.Stops.Contains(position));
+          insertionPosition = insertionTour.Stops.IndexOf(position) + 1;
         } else {
           insertionTour = individual.Tours[position - cities - 1];
@@ -86,36 +78,25 @@
 
         if (!allowInfeasible && insertionTour != originalTour) {
-          bool originalFeasible = RouteFeasible(insertionTour, demand, capacity);
+          bool originalFeasible = problemInstance.TourFeasible(insertionTour, individual);
 
           if (originalFeasible) {
-            double routeLoad = 0;
-            for (int i = 0; i < insertionTour.Cities.Count; i++) {
-              routeLoad += demand[insertionTour.Cities[i]];
+            // try insert into insertionTour
+            insertionTour.Stops.Insert(insertionPosition, city);
+            feasible = problemInstance.TourFeasible(insertionTour, individual);
+
+            if (!feasible) {
+              // when insertionTour is not feasible we undo the change and add to the original tour instead
+              insertionTour.Stops.RemoveAt(insertionPosition);
+              originalTour.Stops.Insert(originalPosition, city);
             }
-            routeLoad += demand[city];
-
-            feasible = routeLoad <= capacity.Value;
-          }
+          } else feasible = false;
         }
-
-        if (feasible) {
-          insertionTour.Cities.Insert(insertionPosition, city);
-        } else {
-          originalTour.Cities.Insert(originalPosition, city);
-        }
-
-        individual.Tours.RemoveAll(t => t.Cities.Count == 0);
+        individual.Tours.RemoveAll(t => t.Stops.Count == 0);
       } while (!feasible);
     }
 
     protected override void Manipulate(IRandom random, PotvinEncoding individual) {
-      BoolValue useDistanceMatrix = UseDistanceMatrixParameter.ActualValue;
-      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
-      DistanceMatrix distMatrix = VRPUtilities.GetDistanceMatrix(coordinates, DistanceMatrixParameter, useDistanceMatrix);
-      DoubleArray demand = DemandParameter.ActualValue;
-      DoubleValue capacity = CapacityParameter.ActualValue;
-
       bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
-      Apply(random, individual, demand, capacity, allowInfeasible);
+      Apply(random, individual, ProblemInstance, allowInfeasible);
     }
   }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptManipulator.cs	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptManipulator.cs	(revision 9750)
@@ -48,5 +48,5 @@
 
     public static void Apply(IRandom random, PotvinEncoding individual) {
-      List<Tour> tours = individual.Tours.FindAll(t => t.Cities.Count >= 4);
+      List<Tour> tours = individual.Tours.FindAll(t => t.Stops.Count >= 4);
 
       if (tours.Count > 0) {
@@ -55,7 +55,7 @@
 
         int a;
-        if (tour.Cities.Count == 4) {
+        if (tour.Stops.Count == 4) {
             a = 0;
-        } else if (tour.Cities.Count == 5) {
+        } else if (tour.Stops.Count == 5) {
           int idx = random.Next(4);
           if (idx >= 2)
@@ -63,10 +63,10 @@
           a = idx;
         } else {
-          a = random.Next(tour.Cities.Count);
+          a = random.Next(tour.Stops.Count);
         }
 
         int b;
         List<int> indices = new List<int>();
-        for (int i = 0; i < tour.Cities.Count; i++) {
+        for (int i = 0; i < tour.Stops.Count; i++) {
           if (Math.Abs(i - a) > 2) {
             indices.Add(i);
@@ -83,8 +83,8 @@
         int index = a + 1;
         int count = b - a - 1;
-        List<int> segment = tour.Cities.GetRange(index, count);
-        tour.Cities.RemoveRange(index, count);
+        List<int> segment = tour.Stops.GetRange(index, count);
+        tour.Stops.RemoveRange(index, count);
         segment.Reverse();
-        tour.Cities.InsertRange(index, segment);
+        tour.Stops.InsertRange(index, segment);
       }
     }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptStarManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptStarManipulator.cs	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptStarManipulator.cs	(revision 9750)
@@ -29,4 +29,5 @@
 using HeuristicLab.Problems.VehicleRouting.Encodings;
 using HeuristicLab.Problems.VehicleRouting;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Analysis.FitnessLandscape.VRP {
@@ -46,14 +47,5 @@
     }
 
-    private static bool RouteFeasible(Tour tour, DoubleArray demand, DoubleValue capacity) {
-      double routeLoad = 0;
-      for (int i = 0; i < tour.Cities.Count; i++) {
-        routeLoad += demand[tour.Cities[i]];
-      }
-
-      return routeLoad <= capacity.Value;
-    }
-
-    public static void Apply(IRandom random, PotvinEncoding individual, DoubleArray demand, DoubleValue capacity, bool allowInfeasible) {
+    public static void Apply(IRandom random, PotvinEncoding individual, IVRPProblemInstance problemInstance, bool allowInfeasible) {
       bool feasible;
 
@@ -72,67 +64,57 @@
         Tour route2 = individual.Tours[route2Idx];
 
-        int x1 = random.Next(route1.Cities.Count + 1);
-        int x2 = random.Next(route2.Cities.Count + 1);
+        int x1 = random.Next(route1.Stops.Count + 1);
+        int x2 = random.Next(route2.Stops.Count + 1);
 
         if (!allowInfeasible) {
-          bool originalFeasible =
-            RouteFeasible(route1, demand, capacity) &&
-            RouteFeasible(route2, demand, capacity);
+          bool originalFeasible = problemInstance.TourFeasible(route1, individual) &&
+                                  problemInstance.TourFeasible(route2, individual);
 
           if (originalFeasible) {
-            double routeLoad = 0;
-            for (int i = 0; i < x1; i++)
-              routeLoad += demand[route1.Cities[i]];
-            for (int i = x2; i < route2.Cities.Count; i++)
-              routeLoad += demand[route2.Cities[i]];
+            int count = route1.Stops.Count - x1;
+            List<int> segmentX1 = new List<int>();
+            if (count > 0) {
+              segmentX1 = route1.Stops.GetRange(x1, count);
+              route1.Stops.RemoveRange(x1, count);
+            }
 
-            if (routeLoad > capacity.Value) {
-              feasible = false;
+            count = route2.Stops.Count - x2;
+            List<int> segmentX2 = new List<int>();
+            if (count > 0) {
+              segmentX2 = route2.Stops.GetRange(x2, count);
+              route2.Stops.RemoveRange(x2, count);
+            }
+
+            route1.Stops.AddRange(segmentX2);
+            feasible = problemInstance.TourFeasible(route1, individual);
+            if (feasible) {
+              route2.Stops.AddRange(segmentX1);
+              feasible = problemInstance.TourFeasible(route2, individual);
+              if (!feasible) {
+                // undo all changes
+                route1.Stops.RemoveRange(x1, segmentX2.Count);
+                route1.Stops.AddRange(segmentX1);
+                route2.Stops.RemoveRange(x2, segmentX1.Count);
+                route2.Stops.AddRange(segmentX2);
+              }
             } else {
-              routeLoad = 0;
-              for (int i = 0; i < x2; i++)
-                routeLoad += demand[route2.Cities[i]];
-              for (int i = x1; i < route1.Cities.Count; i++)
-                routeLoad += demand[route1.Cities[i]];
+              // undo changes 
+              route1.Stops.RemoveRange(x1, segmentX2.Count);
+              route1.Stops.AddRange(segmentX1);
+              route2.Stops.AddRange(segmentX2);
+            }
 
-              if (routeLoad > capacity.Value) {
-                feasible = false;
-              }
-            }
+          } else {
+            feasible = false;
           }
-        }
-
-        if (feasible) {
-          int count = route1.Cities.Count - x1;
-          List<int> segmentX1 = new List<int>();
-          if (count > 0) {
-            segmentX1 = route1.Cities.GetRange(x1, count);
-            route1.Cities.RemoveRange(x1, count);
-          }
-
-          count = route2.Cities.Count - x2;
-          List<int> segmentX2 = new List<int>();
-          if (count > 0) {
-            segmentX2 = route2.Cities.GetRange(x2, count);
-            route2.Cities.RemoveRange(x2, count);
-          }
-
-          route1.Cities.AddRange(segmentX2);
-          route2.Cities.AddRange(segmentX1);
         }
       } while (!feasible);
 
-      individual.Tours.RemoveAll(t => t.Cities.Count == 0);
+      individual.Tours.RemoveAll(t => t.Stops.Count == 0);
     }
 
     protected override void Manipulate(IRandom random, PotvinEncoding individual) {
-      BoolValue useDistanceMatrix = UseDistanceMatrixParameter.ActualValue;
-      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
-      DistanceMatrix distMatrix = VRPUtilities.GetDistanceMatrix(coordinates, DistanceMatrixParameter, useDistanceMatrix);
-      DoubleArray demand = DemandParameter.ActualValue;
-      DoubleValue capacity = CapacityParameter.ActualValue;
-
       bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
-      Apply(random, individual, demand, capacity, allowInfeasible);
+      Apply(random, individual, ProblemInstance, allowInfeasible);
     }
   }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/MultiTrajectory/PreassignedVRPSolutionCreator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/MultiTrajectory/PreassignedVRPSolutionCreator.cs	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/MultiTrajectory/PreassignedVRPSolutionCreator.cs	(revision 9750)
@@ -6,4 +6,5 @@
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Problems.VehicleRouting;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Analysis.FitnessLandscape.MultiTrajectory.VRP {
@@ -12,5 +13,5 @@
   public class PreassignedVRPSolutionCreator : PreassignedSolutionCreator, IVRPCreator {
 
-      
+
     [StorableConstructor]
     protected PreassignedVRPSolutionCreator(bool deserializing) : base(deserializing) { }
@@ -20,13 +21,5 @@
     public PreassignedVRPSolutionCreator() {
       Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The created VRP tour."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Capacity"));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates"));
-      Parameters.Add(new LookupParameter<DoubleArray>("Demand"));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("DistanceMatrix"));
-      Parameters.Add(new LookupParameter<DoubleArray>("DueTime"));
-      Parameters.Add(new LookupParameter<DoubleArray>("ReadyTime"));
-      Parameters.Add(new LookupParameter<DoubleArray>("ServiceTime"));
-      Parameters.Add(new LookupParameter<BoolValue>("UseDistanceMatrix"));
-      Parameters.Add(new LookupParameter<IntValue>("Vehicles"));
+      Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The VRP problem instance."));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -35,5 +28,5 @@
 
     public override void Create(IScope scope) {
-      VRPToursParameter.ActualValue = (IVRPEncoding) scope.Variables[VRPToursParameter.ActualName].Value;
+      VRPToursParameter.ActualValue = (IVRPEncoding)scope.Variables[VRPToursParameter.ActualName].Value;
     }
 
@@ -41,35 +34,11 @@
     #region IVRPCreator Members
     public ILookupParameter<IVRPEncoding> VRPToursParameter {
-      get { return (ILookupParameter<IVRPEncoding>) Parameters["VRPTours"]; }
-    }
-    public ILookupParameter<DoubleValue> CapacityParameter {
-      get { return (ILookupParameter<DoubleValue>) Parameters["Capacity"]; }
-    }
-    public int Cities { get; private set; }
-    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
-      get { return (ILookupParameter<DoubleMatrix>) Parameters["Coordinates"]; }
-    }
-    public ILookupParameter<DoubleArray> DemandParameter {
-      get { return (ILookupParameter<DoubleArray>) Parameters["Demand"]; }
-    }
-    public ILookupParameter<DoubleMatrix> DistanceMatrixParameter {
-      get { return (ILookupParameter<DoubleMatrix>) Parameters["DistanceMatrix"]; }
-    }
-    public ILookupParameter<DoubleArray> DueTimeParameter {
-      get { return (ILookupParameter<DoubleArray>) Parameters["DueTime"]; }
-    }
-    public ILookupParameter<DoubleArray> ReadyTimeParameter {
-      get { return (ILookupParameter<DoubleArray>) Parameters["ReadyTime"]; }
-    }
-    public ILookupParameter<DoubleArray> ServiceTimeParameter {
-      get { return (ILookupParameter<DoubleArray>) Parameters["ServiceTime"]; }
-    }
-    public ILookupParameter<BoolValue> UseDistanceMatrixParameter {
-      get { return (ILookupParameter<BoolValue>) Parameters["UseDistanceMatrix"]; }
-    }
-    public ILookupParameter<IntValue> VehiclesParameter {
-      get { return (ILookupParameter<IntValue>) Parameters["Vehicles"]; }
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
     }
     #endregion
+
+    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
+      get { return (ILookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
+    }
   }
 }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.Views/HeuristicLab.Analysis.FitnessLandscape.Views.csproj
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.Views/HeuristicLab.Analysis.FitnessLandscape.Views.csproj	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.Views/HeuristicLab.Analysis.FitnessLandscape.Views.csproj	(revision 9750)
@@ -99,5 +99,7 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="ALGLIB-3.6.0, Version=3.6.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="ALGLIB-3.7.0, Version=3.7.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Collections-3.3">
       <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.Views/HeuristicLabAnalysisFitnessLandscapeViewsPlugin.cs.frame
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.Views/HeuristicLabAnalysisFitnessLandscapeViewsPlugin.cs.frame	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.Views/HeuristicLabAnalysisFitnessLandscapeViewsPlugin.cs.frame	(revision 9750)
@@ -26,5 +26,5 @@
   [Plugin("HeuristicLab.Analysis.FitnessLandscape.Views", "3.3.0.$WCREV$")]
   [PluginFile("HeuristicLab.Analysis.FitnessLandscape.Views-3.3.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.ALGLIB", "3.6")]
+  [PluginDependency("HeuristicLab.ALGLIB", "3.7")]
   [PluginDependency("HeuristicLab.Analysis.FitnessLandscape", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/HeuristicLab.Analysis.FitnessLandscape.csproj
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/HeuristicLab.Analysis.FitnessLandscape.csproj	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/HeuristicLab.Analysis.FitnessLandscape.csproj	(revision 9750)
@@ -86,5 +86,7 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="ALGLIB-3.6.0, Version=3.6.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="ALGLIB-3.7.0, Version=3.7.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Analysis-3.3">
       <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/HeuristicLabAnalysisFitnessLandscapePlugin.cs.frame
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/HeuristicLabAnalysisFitnessLandscapePlugin.cs.frame	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/HeuristicLabAnalysisFitnessLandscapePlugin.cs.frame	(revision 9750)
@@ -26,5 +26,5 @@
   [Plugin("HeuristicLab.Analysis.FitnessLandscape", "3.3.0.$WCREV$")]
   [PluginFile("HeuristicLab.Analysis.FitnessLandscape-3.3.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.ALGLIB", "3.6")]
+  [PluginDependency("HeuristicLab.ALGLIB", "3.7")]
   [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
Index: branches/FitnessLandscapeAnalysis/VRPProblemAnalyzer/VRPProblemAnalyzer.csproj
===================================================================
--- branches/FitnessLandscapeAnalysis/VRPProblemAnalyzer/VRPProblemAnalyzer.csproj	(revision 9749)
+++ branches/FitnessLandscapeAnalysis/VRPProblemAnalyzer/VRPProblemAnalyzer.csproj	(revision 9750)
@@ -99,6 +99,6 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="ALGLIB-3.6.0">
-      <HintPath>..\..\..\trunk\sources\bin\ALGLIB-3.6.0.dll</HintPath>
+    <Reference Include="ALGLIB-3.7.0">
+      <HintPath>..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
     </Reference>
     <Reference Include="System" />
