Index: /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Instances/3.3/Types/OPData.cs
===================================================================
--- /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Instances/3.3/Types/OPData.cs	(revision 11319)
+++ /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Instances/3.3/Types/OPData.cs	(revision 11320)
@@ -37,5 +37,5 @@
     /// The penalty for each visited vertex.
     /// </summary>
-    public double FixedPenalty { get; set; }
+    public double PointVisitingCosts { get; set; }
     /// <summary>
     /// Index of the starting point
Index: /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Creators/GreedyOrienteeringTourCreator.cs
===================================================================
--- /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Creators/GreedyOrienteeringTourCreator.cs	(revision 11319)
+++ /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Creators/GreedyOrienteeringTourCreator.cs	(revision 11320)
@@ -55,6 +55,6 @@
       get { return (ILookupParameter<IntValue>)Parameters["TerminalPoint"]; }
     }
-    public ILookupParameter<DoubleValue> FixedPenaltyParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["FixedPenalty"]; }
+    public ILookupParameter<DoubleValue> PointVisitingCostsParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["PointVisitingCosts"]; }
     }
     #endregion
@@ -73,5 +73,5 @@
       Parameters.Add(new LookupParameter<IntValue>("StartingPoint", "Index of the starting point."));
       Parameters.Add(new LookupParameter<IntValue>("TerminalPoint", "Index of the ending point."));
-      Parameters.Add(new LookupParameter<DoubleValue>("FixedPenalty", "The penalty for each visited vertex."));
+      Parameters.Add(new LookupParameter<DoubleValue>("PointVisitingCosts", "The costs for visiting a point."));
     }
 
@@ -85,5 +85,5 @@
       int numPoints = ScoresParameter.ActualValue.Length;
       var distances = DistanceMatrixParameter.ActualValue;
-      double fixedPenalty = FixedPenaltyParameter.ActualValue.Value;
+      double pointVisitingCosts = PointVisitingCostsParameter.ActualValue.Value;
       double maxDistance = MaximumDistanceParameter.ActualValue.Value;
       var scores = ScoresParameter.ActualValue;
@@ -92,5 +92,5 @@
       var feasiblePoints = (
         from point in Enumerable.Range(0, numPoints)
-        let distance = distances[startPoint, point] + distances[point, endPoint] + fixedPenalty
+        let distance = distances[startPoint, point] + distances[point, endPoint] + pointVisitingCosts
         let score = scores[point]
         where distance <= maxDistance
@@ -115,5 +115,5 @@
           for (int insertPosition = 1; insertPosition < tour.Count; insertPosition++) {
             // Create the candidate tour
-            double detour = distances.CalculateInsertionCosts(tour, insertPosition, feasiblePoints[i], fixedPenalty);
+            double detour = distances.CalculateInsertionCosts(tour, insertPosition, feasiblePoints[i], pointVisitingCosts);
 
             // If the insertion would be feasible, perform it
Index: /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/DistanceMatrix.cs
===================================================================
--- /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/DistanceMatrix.cs	(revision 11319)
+++ /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/DistanceMatrix.cs	(revision 11320)
@@ -53,15 +53,15 @@
     }
 
-    public double CalculateTourLength(IList<int> path, double fixedPenalty) {
+    public double CalculateTourLength(IList<int> path, double pointVisitingCosts) {
       double length = 0.0;
       for (int i = 1; i < path.Count; i++)
         length += this[path[i - 1], path[i]];
       // Add the fixed penalty for every vertex except for the starting and ending vertex
-      length += (path.Count - 2) * fixedPenalty;
+      length += (path.Count - 2) * pointVisitingCosts;
       return length;
     }
-    public double CalculateInsertionCosts(IList<int> path, int insertPosition, int point, double fixedPenalty) {
+    public double CalculateInsertionCosts(IList<int> path, int insertPosition, int point, double pointVisitingCosts) {
       double detour = this[path[insertPosition - 1], point] + this[point, path[insertPosition]];
-      detour += fixedPenalty;
+      detour += pointVisitingCosts;
       detour -= this[path[insertPosition - 1], path[insertPosition]];
       return detour;
@@ -72,9 +72,9 @@
       return detour;
     }
-    public double CalculateRemovementSaving(List<int> path, int removePosition, double fixedPenalty) {
+    public double CalculateRemovementSaving(List<int> path, int removePosition, double pointVisitingCosts) {
       double saving = this[path[removePosition - 1], path[removePosition]];
       saving += this[path[removePosition], path[removePosition + 1]];
       saving -= this[path[removePosition - 1], path[removePosition + 1]];
-      saving += fixedPenalty;
+      saving += pointVisitingCosts;
       return saving;
     }
Index: /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Evaluators/OrienteeringEvaluator.cs
===================================================================
--- /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Evaluators/OrienteeringEvaluator.cs	(revision 11319)
+++ /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Evaluators/OrienteeringEvaluator.cs	(revision 11320)
@@ -55,6 +55,6 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["MaximumDistance"]; }
     }
-    public ILookupParameter<DoubleValue> FixedPenaltyParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["FixedPenalty"]; }
+    public ILookupParameter<DoubleValue> PointVisitingCostsParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["PointVisitingCosts"]; }
     }
     #endregion
@@ -80,5 +80,5 @@
       Parameters.Add(new LookupParameter<DistanceMatrix>("DistanceMatrix", "The matrix which contains the distances between the points."));
       Parameters.Add(new LookupParameter<DoubleValue>("MaximumDistance", "The maximum distance constraint for a Orienteering solution."));
-      Parameters.Add(new LookupParameter<DoubleValue>("FixedPenalty", "The penalty for each visited vertex."));
+      Parameters.Add(new LookupParameter<DoubleValue>("PointVisitingCosts", "The costs for visiting a point."));
     }
 
@@ -89,8 +89,8 @@
 
     public static OrienteeringEvaluation Apply(IntegerVector solution, DoubleArray scores,
-      DistanceMatrix distances, DoubleValue maximumDistance, DoubleValue fixedPenalty, DoubleValue distancePenaltyFactor) {
+      DistanceMatrix distances, DoubleValue maximumDistance, DoubleValue pointVisitingCosts, DoubleValue distancePenaltyFactor) {
 
       double score = solution.Sum(t => scores[t]);
-      double distance = distances.CalculateTourLength(solution.ToList(), fixedPenalty.Value);
+      double distance = distances.CalculateTourLength(solution.ToList(), pointVisitingCosts.Value);
 
       double distanceViolation = distance - maximumDistance.Value;
@@ -110,5 +110,5 @@
       var evaluation = Apply(IntegerVectorParameter.ActualValue, ScoresParameter.ActualValue,
         DistanceMatrixParameter.ActualValue, MaximumDistanceParameter.ActualValue,
-        FixedPenaltyParameter.ActualValue, DistancePenaltyFactorParameter.ActualValue);
+        PointVisitingCostsParameter.ActualValue, DistancePenaltyFactorParameter.ActualValue);
 
       QualityParameter.ActualValue = evaluation.Quality;
Index: /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Improvers/OrienteeringLocalImprovementOperator.cs
===================================================================
--- /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Improvers/OrienteeringLocalImprovementOperator.cs	(revision 11319)
+++ /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Improvers/OrienteeringLocalImprovementOperator.cs	(revision 11320)
@@ -58,6 +58,6 @@
       get { return (ILookupParameter<IntValue>)Parameters["TerminalPoint"]; }
     }
-    public ILookupParameter<DoubleValue> FixedPenaltyParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["FixedPenalty"]; }
+    public ILookupParameter<DoubleValue> PointVisitingCostsParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["PointVisitingCosts"]; }
     }
     #region ILocalImprovementOperator Parameters
@@ -99,5 +99,5 @@
       Parameters.Add(new LookupParameter<IntValue>("StartingPoint", "Index of the starting point."));
       Parameters.Add(new LookupParameter<IntValue>("TerminalPoint", "Index of the ending point."));
-      Parameters.Add(new LookupParameter<DoubleValue>("FixedPenalty", "The penalty for each visited vertex."));
+      Parameters.Add(new LookupParameter<DoubleValue>("PointVisitingCosts", "The costs for visiting a point."));
 
       Parameters.Add(new ValueLookupParameter<IntValue>("LocalIterations", "The number of iterations that have already been performed.", new IntValue(0)));
@@ -119,5 +119,5 @@
       var distances = DistanceMatrixParameter.ActualValue;
       var scores = ScoresParameter.ActualValue;
-      double fixedPenalty = FixedPenaltyParameter.ActualValue.Value;
+      double pointVisitingCosts = PointVisitingCostsParameter.ActualValue.Value;
       double maxLength = MaximumDistanceParameter.ActualValue.Value;
       int maxIterations = MaximumIterationsParameter.ActualValue.Value;
@@ -129,5 +129,5 @@
       var tour = IntegerVectorParameter.ActualValue.ToList();
 
-      double tourLength = distances.CalculateTourLength(tour, fixedPenalty);
+      double tourLength = distances.CalculateTourLength(tour, pointVisitingCosts);
       double tourScore = tour.Sum(point => scores[point]);
 
@@ -148,5 +148,5 @@
         // Determine if any of the visitable points can be included at any position within the tour
         IncludeNewPoints(tour, visitablePoints,
-          distances, fixedPenalty, maxLength, scores,
+          distances, pointVisitingCosts, maxLength, scores,
           ref tourLength, ref tourScore, ref evaluations, ref optimizationDone);
 
@@ -211,5 +211,5 @@
     }
     private void IncludeNewPoints(List<int> tour, List<int> visitablePoints,
-      DistanceMatrix distances, double fixedPenalty, double maxLength, DoubleArray scores,
+      DistanceMatrix distances, double pointVisitingCosts, double maxLength, DoubleArray scores,
       ref double tourLength, ref double tourScore, ref int evaluations, ref bool optimizationDone) {
 
@@ -224,5 +224,5 @@
           evaluations++;
 
-          double detour = distances.CalculateInsertionCosts(tour, tourPosition, visitablePoints[i], fixedPenalty);
+          double detour = distances.CalculateInsertionCosts(tour, tourPosition, visitablePoints[i], pointVisitingCosts);
 
           // Determine if including the point does not violate any constraint
Index: /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/OrienteeringProblem.cs
===================================================================
--- /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/OrienteeringProblem.cs	(revision 11319)
+++ /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/OrienteeringProblem.cs	(revision 11320)
@@ -64,6 +64,6 @@
       get { return (ValueParameter<DoubleArray>)Parameters["Scores"]; }
     }
-    public ValueParameter<DoubleValue> FixedPenaltyParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["FixedPenalty"]; }
+    public ValueParameter<DoubleValue> PointVisitingCostsParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["PointVisitingCosts"]; }
     }
 
@@ -98,7 +98,7 @@
       set { ScoresParameter.Value = value; }
     }
-    public DoubleValue FixedPenalty {
-      get { return FixedPenaltyParameter.Value; }
-      set { FixedPenaltyParameter.Value = value; }
+    public DoubleValue PointVisitingCosts {
+      get { return PointVisitingCostsParameter.Value; }
+      set { PointVisitingCostsParameter.Value = value; }
     }
     public IntegerVector BestKnownSolution {
@@ -130,5 +130,5 @@
       Parameters.Add(new ValueParameter<DoubleValue>("MaximumDistance", "The maximum distance constraint for a Orienteering solution."));
       Parameters.Add(new ValueParameter<DoubleArray>("Scores", "The scores of the points."));
-      Parameters.Add(new ValueParameter<DoubleValue>("FixedPenalty", "The penalty for each visited vertex."));
+      Parameters.Add(new ValueParameter<DoubleValue>("PointVisitingCosts", "The costs for visiting a point."));
       Parameters.Add(new OptionalValueParameter<IntegerVector>("BestKnownSolution", "The best known solution of this Orienteering instance."));
 
@@ -204,5 +204,5 @@
       ParameterizeSolutionCreator();
     }
-    private void FixedPenaltyParameter_ValueChanged(object sender, EventArgs e) {
+    private void PointVisitingCostsParameter_ValueChanged(object sender, EventArgs e) {
       ParameterizeEvaluator();
       ParameterizeAnalyzer();
@@ -231,5 +231,5 @@
       ScoresParameter.ValueChanged += ScoresParameter_ValueChanged;
       ScoresParameter.Value.Reset += ScoresValue_Reset;
-      FixedPenaltyParameter.ValueChanged += FixedPenaltyParameter_ValueChanged;
+      PointVisitingCostsParameter.ValueChanged += PointVisitingCostsParameter_ValueChanged;
     }
 
@@ -242,5 +242,5 @@
         creator.StartingPointParameter.ActualName = StartingPointParameter.Name;
         creator.TerminalPointParameter.ActualName = TerminalPointParameter.Name;
-        creator.FixedPenaltyParameter.ActualName = FixedPenaltyParameter.Name;
+        creator.PointVisitingCostsParameter.ActualName = PointVisitingCostsParameter.Name;
       }
     }
@@ -281,5 +281,5 @@
         op.StartingPointParameter.ActualName = StartingPointParameter.Name;
         op.TerminalPointParameter.ActualName = TerminalPointParameter.Name;
-        op.FixedPenaltyParameter.ActualName = FixedPenaltyParameter.Name;
+        op.PointVisitingCostsParameter.ActualName = PointVisitingCostsParameter.Name;
       }
       foreach (var op in Operators.OfType<OrienteeringShakingOperator>()) {
@@ -290,5 +290,5 @@
         op.StartingPointParameter.ActualName = StartingPointParameter.Name;
         op.TerminalPointParameter.ActualName = TerminalPointParameter.Name;
-        op.FixedPenaltyParameter.ActualName = FixedPenaltyParameter.Name;
+        op.PointVisitingCostsParameter.ActualName = PointVisitingCostsParameter.Name;
       }
     }
@@ -362,4 +362,5 @@
       TerminalPoint = new IntValue(data.TerminalPoint);
 
+      PointVisitingCosts = new DoubleValue(data.PointVisitingCosts);
       MaximumDistance = new DoubleValue(data.MaximumDistance);
       Scores = new DoubleArray(data.Scores);
@@ -388,4 +389,5 @@
       TerminalPoint = new IntValue(data.Dimension - 1); // Last city is interpreted als end point
 
+      PointVisitingCosts = new DoubleValue(0);
       MaximumDistance = new DoubleValue(DistanceMatrix.Average() * 5.0); // distance from start to end first to last city is interpreted as maximum distance
       Scores = new DoubleArray(Enumerable.Repeat(1.0, data.Dimension).ToArray()); // all scores are 1
@@ -413,8 +415,7 @@
       TerminalPoint = new IntValue(0); // Depot is interpreted als end point
 
+      PointVisitingCosts = new DoubleValue(0);
       MaximumDistance = new DoubleValue(data.Capacity * 2); // capacity is interpreted as max distance
       Scores = new DoubleArray(data.Demands); // demands are interpreted as scores
-
-      OnReset();
     }
   }
Index: /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Shakers/OrienteeringShakingOperator.cs
===================================================================
--- /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Shakers/OrienteeringShakingOperator.cs	(revision 11319)
+++ /branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Shakers/OrienteeringShakingOperator.cs	(revision 11320)
@@ -76,6 +76,6 @@
       get { return (ILookupParameter<DoubleArray>)Parameters["Scores"]; }
     }
-    public ILookupParameter<DoubleValue> FixedPenaltyParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["FixedPenalty"]; }
+    public ILookupParameter<DoubleValue> PointVisitingCostsParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["PointVisitingCosts"]; }
     }
 
@@ -101,5 +101,5 @@
       Parameters.Add(new LookupParameter<DistanceMatrix>("DistanceMatrix", "The matrix which contains the distances between the points."));
       Parameters.Add(new LookupParameter<DoubleArray>("Scores", "The scores of the points."));
-      Parameters.Add(new LookupParameter<DoubleValue>("FixedPenalty", "The penalty for each visited vertex."));
+      Parameters.Add(new LookupParameter<DoubleValue>("PointVisitingCosts", "The costs for visiting a point."));
 
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator that will be used."));
@@ -116,5 +116,5 @@
       var startingPoint = StartingPointParameter.ActualValue.Value;
       var terminalPoint = TerminalPointParameter.ActualValue.Value;
-      var fixedPenalty = FixedPenaltyParameter.ActualValue.Value;
+      var pointVisitingCosts = PointVisitingCostsParameter.ActualValue.Value;
       double maxDistance = MaximumDistanceParameter.ActualValue.Value;
       int numPoints = scores.Length;
@@ -139,5 +139,5 @@
           from point in Enumerable.Range(0, numPoints)
           // Calculate the distance when going from the starting point to this point and then to the end point
-          let distance = distances[startingPoint, point] + distances[point, terminalPoint] + fixedPenalty
+          let distance = distances[startingPoint, point] + distances[point, terminalPoint] + pointVisitingCosts
           // If this distance is feasible and the point is neither starting nor ending point, check the point
           where distance < maxDistance && point != startingPoint && point != terminalPoint
@@ -157,5 +157,5 @@
 
         // Bring the tour back to be feasible 
-        CleanupTour(actualTour, distances, maxDistance, fixedPenalty);
+        CleanupTour(actualTour, distances, maxDistance, pointVisitingCosts);
 
         // Set new Tour
@@ -208,14 +208,14 @@
       }
     }
-    private void CleanupTour(List<int> actualTour, DistanceMatrix distances, double maxDistance, double fixedPenalty) {
+    private void CleanupTour(List<int> actualTour, DistanceMatrix distances, double maxDistance, double pointVisitingCosts) {
       // Sort the points on the tour according to their costs savings when removed
       var distanceSavings = (
         from removePosition in Enumerable.Range(1, actualTour.Count - 2)
-        let saving = distances.CalculateRemovementSaving(actualTour, removePosition, fixedPenalty)
+        let saving = distances.CalculateRemovementSaving(actualTour, removePosition, pointVisitingCosts)
         orderby saving descending
         select new SavingInfo { Index = removePosition, Saving = saving }
       ).ToList();
 
-      double tourLength = distances.CalculateTourLength(actualTour, fixedPenalty);
+      double tourLength = distances.CalculateTourLength(actualTour, pointVisitingCosts);
 
       // As long as the created path is infeasible, remove elements
@@ -223,5 +223,5 @@
         // Remove the point that frees the largest distance
         // Note, distance savings are not updated after removal
-        tourLength -= distances.CalculateRemovementSaving(actualTour, distanceSavings[0].Index, fixedPenalty);
+        tourLength -= distances.CalculateRemovementSaving(actualTour, distanceSavings[0].Index, pointVisitingCosts);
         actualTour.RemoveAt(distanceSavings[0].Index);
 
