Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs	(revision 15332)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs	(revision 15333)
@@ -39,4 +39,6 @@
         private const string AverageAcceptanceRatioName = "AverageAcceptanceRatio";
         private const string ReheatWindowSizeName = "ReheatWindowSize";
+        private const string LastAcceptedQualityName = "LastAcceptedQuality";
+        private const string MoveQualityName = "MoveQuality";
 
 
@@ -67,7 +69,7 @@
             get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
         }
-        public ILookupParameter<IOperator> AnnealingOperatorParameter
-        {
-            get { return (ILookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        public ILookupParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
         }
         public ILookupParameter<IntValue> MaximumIterationsParameter
@@ -110,4 +112,12 @@
         {
             get { return (IValueParameter<IntValue>)Parameters[ReheatWindowSizeName]; }
+        }
+        public ILookupParameter<DoubleValue> MoveQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> LastAcceptedQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LastAcceptedQualityName]; }
         }
 
@@ -120,5 +130,5 @@
             Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
             Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
-            Parameters.Add(new LookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new LookupParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator that cools the temperature."));
             Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
             Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
@@ -134,4 +144,6 @@
             Parameters.Add(new LookupParameter<DoubleValue>(AverageAcceptanceRatioName, "Average acceptance over full acceptance memory."));
             Parameters.Add(new ValueParameter<IntValue>(ReheatWindowSizeName, "The amount of iterations each reheat needs to heat the current temperature to upper temperature.", new IntValue(10000)));
+            Parameters.Add(new LookupParameter<DoubleValue>(LastAcceptedQualityName, "Quality of last accepted solution."));
+            Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
             #endregion
 
@@ -173,13 +185,11 @@
         public override IOperation Apply()
         {
-            var isAccepted = IsAcceptedParameter.ActualValue;
+            var isAccepted = IsAcceptedParameter.ActualValue.Value && LastAcceptedQualityParameter.ActualValue.Value != MoveQualityParameter.ActualValue.Value;
             var acceptances = AcceptanceMemoryParameter.ActualValue;
             var cooling = CoolingParameter.ActualValue.Value;
             var ratioAmount = AverageAcceptanceRatioParameter.ActualValue;
 
-            acceptances.Add(isAccepted);
-
-            ratioAmount.Value += isAccepted.Value ? 1 : 0;
-
+            acceptances.Add(new BoolValue(isAccepted));
+            ratioAmount.Value += isAccepted ? 1 : 0;
 
             if (acceptances.Count > MemorySizeParameter.Value.Value) {
@@ -216,4 +226,10 @@
                 CoolingParameter.ActualValue.Value = cooling;
             }
+
+            if (isAccepted)
+            {
+                LastAcceptedQualityParameter.ActualValue.Value = MoveQualityParameter.ActualValue.Value;
+            }
+
             return cooling ? Cool() : Heat();
         }
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AdaptiveReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AdaptiveReheatingOperator.cs	(revision 15333)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AdaptiveReheatingOperator.cs	(revision 15333)
@@ -0,0 +1,186 @@
+﻿using HeuristicLab.Operators;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Analysis;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("AdaptiveReheatingOperator", "Next to the annealing schedule, a hotter schedule is generated. Whenever a solution is accepted, the temperature of the annealing schedule is used. Whenever a solution is rejected, the temperature of the heating schedule is chosen.")]
+    [StorableClass]
+    public class AdaptiveReheatingOperator : SingleSuccessorOperator, IReheatingOperator
+    {
+        #region Strings
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string MaximumIterationsName = "MaximumIterations";
+        private const string InitialTemperatureName = "InitialTemperature";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string LastAcceptedQualityName = "LastAcceptedQuality";
+        private const string MoveQualityName = "MoveQuality";
+
+        private const string ReheatingOperatorName = "ReheatingOperator";
+        private const string OtherLowerTemperatureName = "OtherLowerTemperature";
+
+        #endregion
+
+        #region Parameters
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> EndTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public ILookupParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
+        }
+        public ILookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<DoubleValue> MoveQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> LastAcceptedQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LastAcceptedQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> InitialTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[InitialTemperatureName]; }
+        }
+        private IConstrainedValueParameter<IDiscreteDoubleValueModifier> ReheatingOperatorParameter
+        {
+            get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters[ReheatingOperatorName]; }
+        }
+        private ValueParameter<DoubleValue> OtherLowerTemperatureParameter
+        {
+            get { return (ValueParameter<DoubleValue>)Parameters[OtherLowerTemperatureName]; }
+        }
+
+        #endregion
+
+        public AdaptiveReheatingOperator() : base()
+        {
+            #region Create parameters
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new LookupParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling should occur."));
+            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled."));
+            Parameters.Add(new LookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
+            Parameters.Add(new LookupParameter<BoolValue>(IsAcceptedName, "Whether the move was accepted or not."));
+            Parameters.Add(new LookupParameter<DoubleValue>(LastAcceptedQualityName, "Quality of last accepted solution."));
+            Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
+            Parameters.Add(new LookupParameter<DoubleValue>(InitialTemperatureName, "The initial temperature."));
+            Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>(ReheatingOperatorName, "The operator that reheats the temperature."));
+            Parameters.Add(new ValueParameter<DoubleValue>(OtherLowerTemperatureName, "The upper bound of the temperature of the heating schedule.", new DoubleValue(10)));
+
+
+            foreach (var op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
+            {
+                ReheatingOperatorParameter.ValidValues.Add((IDiscreteDoubleValueModifier)op);
+            }
+
+            #endregion
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected AdaptiveReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected AdaptiveReheatingOperator(AdaptiveReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new AdaptiveReheatingOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+            foreach (var op in ReheatingOperatorParameter.ValidValues)
+            {
+                op.IndexParameter.ActualName = IterationsName;
+                op.IndexParameter.Hidden = true;
+                op.StartIndexParameter.Value = null;
+                op.StartIndexParameter.ActualName = TemperatureStartIndexName;
+                op.EndIndexParameter.ActualName = MaximumIterationsParameter.Name;
+                op.ValueParameter.ActualName = TemperatureName;
+                op.ValueParameter.Hidden = true;
+                op.StartValueParameter.ActualName = StartTemperatureName;
+                op.StartValueParameter.Hidden = true;
+                op.EndValueParameter.Value = OtherLowerTemperatureParameter.Value;
+                op.EndValueParameter.Hidden = true;
+            }
+        }
+
+        public override IOperation Apply()
+        {     
+            if(!IsAcceptedParameter.ActualValue.Value || LastAcceptedQualityParameter.ActualValue.Value.Equals(MoveQualityParameter.ActualValue.Value))
+            {
+                return Heat();
+            }else
+            {
+                return Cool();
+            }
+        }
+
+
+        private IOperation Heat()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(ReheatingOperatorParameter.Value),
+                    base.Apply()
+                };
+        }
+
+        private IOperation Cool()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs	(revision 15332)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs	(revision 15333)
@@ -30,9 +30,10 @@
         private const string MaximumIterationsName = "MaximumIterations";
         private const string InitialTemperatureName = "InitialTemperature";
-
         private const string ThresholdName = "Threshold";
         private const string IsAcceptedName = "IsAccepted";
         private const string ConsecutiveRejectedSolutionsCountName = "ConsecutiveRejectedSolutions";
         private const string ResetTemperatureName = "ResetTemperature";
+        private const string LastAcceptedQualityName = "LastAcceptedQuality";
+        private const string MoveQualityName = "MoveQuality";
         #endregion
 
@@ -86,4 +87,12 @@
             get { return (ILookupParameter<IntValue>)Parameters[ConsecutiveRejectedSolutionsCountName]; }
         }
+        public ILookupParameter<DoubleValue> MoveQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> LastAcceptedQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LastAcceptedQualityName]; }
+        }
         #endregion
 
@@ -103,5 +112,7 @@
             Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive rejected solutions must occur to trigger a reheat.", new IntValue(10)));
             Parameters.Add(new ValueLookupParameter<DoubleValue>(ResetTemperatureName, "The base reset temperature.", InitialTemperatureName));
-          
+            Parameters.Add(new LookupParameter<DoubleValue>(LastAcceptedQualityName, "Quality of last accepted solution."));
+            Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
+
             #endregion
 
@@ -125,11 +136,24 @@
         public override IOperation Apply()
         {
-            var count = ConsecutiveRejectedSolutionsCountParameter.ActualValue;
+            if(!IsAcceptedParameter.ActualValue.Value || LastAcceptedQualityParameter.ActualValue.Value.Equals(MoveQualityParameter.ActualValue.Value))
+            {
+                ConsecutiveRejectedSolutionsCountParameter.ActualValue.Value++;
+            }else
+            {
+                ConsecutiveRejectedSolutionsCountParameter.ActualValue.Value = 0;
+            }
 
-            count.Value = !IsAcceptedParameter.ActualValue.Value ? count.Value + 1 : 0;
 
-            var heating = count.Value == ThresholdParameter.Value.Value;
+            var heating = ConsecutiveRejectedSolutionsCountParameter.ActualValue.Value >= ThresholdParameter.Value.Value;
 
-            if(heating) count.Value = 0;
+            if (heating)
+            {
+                ConsecutiveRejectedSolutionsCountParameter.ActualValue.Value = 0;
+            }
+
+            if (IsAcceptedParameter.ActualValue.Value)
+            {
+                LastAcceptedQualityParameter.ActualValue.Value = MoveQualityParameter.ActualValue.Value;
+            }
 
             return heating ? Heat() : Cool();
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/NoReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/NoReheatingOperator.cs	(revision 15332)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/NoReheatingOperator.cs	(revision 15333)
@@ -22,46 +22,10 @@
         #region Strings
         private const string AnnealingOperatorName = "AnnealingOperator";
-        private const string LowerTemperatureName = "LowerTemperature";
-        private const string IterationsName = "Iterations";
-        private const string TemperatureStartIndexName = "TemperatureStartIndex";
-        private const string StartTemperatureName = "StartTemperature";
-        private const string EndTemperatureName = "EndTemperature";
-        private const string TemperatureName = "Temperature";
-        private const string MaximumIterationsName = "MaximumIterations";
-
 
         #endregion
-        #region Parameters
-        public ILookupParameter<DoubleValue> TemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> LowerTemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> StartTemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> EndTemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
-        }
-        public ILookupParameter<IntValue> TemperatureStartIndexParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
-        }
-        public ILookupParameter<IntValue> IterationsParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
-        }
+        #region Parameters      
         public ILookupParameter<IOperator> AnnealingOperatorParameter
         {
             get { return (ILookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
-        }
-        public ILookupParameter<IntValue> MaximumIterationsParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
         }
 
@@ -71,11 +35,4 @@
         {
             #region Create parameters
-            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
-            Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
-            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
-            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
-            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
-            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled or heated."));
-            Parameters.Add(new LookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
             Parameters.Add(new LookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
             #endregion
@@ -100,7 +57,4 @@
         public override IOperation Apply()
         {
-            TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
-            StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
-            EndTemperatureParameter.ActualValue.Value = LowerTemperatureParameter.ActualValue.Value;
             return new OperationCollection {
                     ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/RandomWalkReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/RandomWalkReheatingOperator.cs	(revision 15332)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/RandomWalkReheatingOperator.cs	(revision 15333)
@@ -29,6 +29,4 @@
         private const string TemperatureName = "Temperature";
         private const string MaximumIterationsName = "MaximumIterations";
-
-        private const string TemperatureBeforeReheatName = "TemperatureBeforeReheat";
         private const string CurrentRandomWalkStepName = "CurrentRandomWalkStep";
         private const string RandomWalkLengthName = "RandomWalkLength";
@@ -36,12 +34,7 @@
         private const string IsAcceptedName = "IsAccepted";
         private const string ConsecutiveRejectedSolutionsCountName = "ConsecutiveRejectedSolutions";
-        private const string QualitiesBeforeReheatingName = "QualitiesBeforeReheating";
-        private const string AmountOfReheatsName = "AmountOfReheats";
-        private const string RetrappedName = "Retrapped";
         private const string LastAcceptedQualityName = "LastAcceptedQuality";
-        private const string ResultsName = "Results";
         private const string MoveQualityName = "MoveQuality";
         private const string CoolingName = "Cooling";
-        private const string TabuListActiveName = "TabuListActive";
 
 
@@ -105,12 +98,4 @@
             get { return (ILookupParameter<IntValue>)Parameters[CurrentRandomWalkStepName]; }
         }
-        public ILookupParameter<DoubleValue> TemperatureBeforeReheatParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureBeforeReheatName]; }
-        }
-        private LookupParameter<ItemList<DoubleValue>> QualitiesBeforeReheatingParameter
-        {
-            get { return (LookupParameter<ItemList<DoubleValue>>)Parameters[QualitiesBeforeReheatingName]; }
-        }
         public ILookupParameter<BoolValue> CoolingParameter
         {
@@ -124,8 +109,4 @@
         {
             get { return (ILookupParameter<DoubleValue>)Parameters[LastAcceptedQualityName]; }
-        }
-        public IValueParameter<BoolValue> TabuListActiveParameter
-        {
-            get { return (IValueParameter<BoolValue>)Parameters[TabuListActiveName];  }
         }
 
@@ -145,14 +126,10 @@
             Parameters.Add(new LookupParameter<BoolValue>(IsAcceptedName, "Whether the move was accepted or not."));
             Parameters.Add(new LookupParameter<IntValue>(ConsecutiveRejectedSolutionsCountName, "Amount of consecutive rejected solutions."));
-            Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive rejected solutions must occur to trigger a reheat.", new IntValue(10)));
-            Parameters.Add(new ValueParameter<IntValue>(RandomWalkLengthName, "Amount of randomly accepted moves upon reheat.", new IntValue(2)));
+            Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive rejected solutions must occur to trigger a reheat.", new IntValue(10000)));
+            Parameters.Add(new ValueParameter<IntValue>(RandomWalkLengthName, "Amount of randomly accepted moves upon reheat.", new IntValue(1)));
             Parameters.Add(new LookupParameter<IntValue>(CurrentRandomWalkStepName, "Current random walk step."));
-            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureBeforeReheatName, "Temperature before the reheat occured."));
-            Parameters.Add(new LookupParameter<ItemList<DoubleValue>>(QualitiesBeforeReheatingName, "Quality of last optimum."));
             Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
             Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
             Parameters.Add(new LookupParameter<DoubleValue>(LastAcceptedQualityName, "Quality of last accepted solution."));
-            Parameters.Add(new ValueParameter<BoolValue>(TabuListActiveName, "Determines whether visiting a 'frozen' quality instantly triggers a reheat or not", new BoolValue(true)));
-
             #endregion
 
@@ -176,113 +153,55 @@
         public override IOperation Apply()
         {
-            var isAccepted = IsAcceptedParameter.ActualValue.Value;
-            var consecutiveRejectedCount = ConsecutiveRejectedSolutionsCountParameter.ActualValue;
             var cooling = CoolingParameter.ActualValue.Value;
-            var frozenSolutions = QualitiesBeforeReheatingParameter.ActualValue;
             var quality = MoveQualityParameter.ActualValue;
             var lastAcceptedQuality = LastAcceptedQualityParameter.ActualValue;
-            var tabuListActive = TabuListActiveParameter.Value.Value;
-
-            if(isAccepted)
+            var isAccepted = IsAcceptedParameter.ActualValue.Value;
+            var consecutiveRejectedSolutionsCount = ConsecutiveRejectedSolutionsCountParameter.ActualValue;
+
+            if (cooling)
+            {
+                // add acceptance value to consecutive rejected solutions count
+                // if quality hasnt changed, we might be stuck on a plateau
+                if (!isAccepted || quality.Value.Equals(lastAcceptedQuality.Value))
+                {
+                    consecutiveRejectedSolutionsCount.Value++;
+                }
+                else
+                {
+                    consecutiveRejectedSolutionsCount.Value = 0;
+                }
+
+                // check if we are trapped in a local optimum
+                if (consecutiveRejectedSolutionsCount.Value >= ThresholdParameter.Value.Value)
+                {
+                    cooling = false;
+                    consecutiveRejectedSolutionsCount.Value = 0;
+                }
+            }
+
+
+            if (!cooling)
+            {
+                // random walk finished, start cooling again
+                if (RandomWalkLengthParameter.Value.Value <= CurrentRandomWalkStepParameter.ActualValue.Value)
+                {
+                    cooling = true;
+                    CurrentRandomWalkStepParameter.ActualValue.Value = 0;
+                }
+                else
+                {
+                    CurrentRandomWalkStepParameter.ActualValue.Value++;
+                }
+            }
+
+            if (isAccepted)
             {
                 LastAcceptedQualityParameter.ActualValue.Value = quality.Value;
             }
 
-            if (cooling)
-            { 
-                // check if we are re-trapped
-                if (isAccepted && frozenSolutions.Any(frozen => frozen.Value.Equals(quality.Value)) && tabuListActive)
-                {
-                   cooling = false;
-
-                    IntValue retrapped = new IntValue(0);
-                    IResult retrappedAmount;
-                    var results = (ResultCollection)ExecutionContext.Parent.Parent.Scope.Variables[ResultsName].Value;
-                    if (results.TryGetValue(RetrappedName, out retrappedAmount))
-                    {
-                        retrapped = (IntValue)retrappedAmount.Value;
-                        retrapped.Value += 1;
-                    }
-                    else
-                    {
-                        retrapped.Value += 1;
-                        results.Add(new Result(RetrappedName, retrapped));
-                    }
-                    // remember local optimum
-                    frozenSolutions.Add(new DoubleValue(lastAcceptedQuality.Value));
-                }
-                else
-                {
-                    // add acceptance value to consecutive rejected solutions count
-                    consecutiveRejectedCount.Value = !IsAcceptedParameter.ActualValue.Value ? consecutiveRejectedCount.Value + 1 : 0;
-
-                    // check if we are trapped in a new local optimum
-                    if (consecutiveRejectedCount.Value == ThresholdParameter.Value.Value)
-                    {
-                        cooling = false;
-                        consecutiveRejectedCount.Value = 0;
-                        // remember local optimum
-                        frozenSolutions.Add(new DoubleValue(lastAcceptedQuality.Value));
-                    }
-                }
-            }
-            else
-            {
-                // random walk not yet finished
-                if (RandomWalkLengthParameter.Value.Value != CurrentRandomWalkStepParameter.ActualValue.Value)
-                {
-                    if (CurrentRandomWalkStepParameter.ActualValue.Value == 0)
-                    {
-                        DebugIncreaseReheatCounter();
-                    }
-                    CurrentRandomWalkStepParameter.ActualValue.Value++;
-                }
-                else
-                {
-                    // random walk finished start cooling again
-                    cooling = true;
-                    TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
-                    StartTemperatureParameter.ActualValue.Value = TemperatureBeforeReheatParameter.ActualValue.Value;
-                    EndTemperatureParameter.ActualValue.Value = LowerTemperatureParameter.ActualValue.Value;
-                    consecutiveRejectedCount.Value = isAccepted ? 0 : 1;
-                    CurrentRandomWalkStepParameter.ActualValue.Value = 0;
-
-                }
-            }
             CoolingParameter.ActualValue.Value = cooling;
             return cooling ? Cool() : Heat();
         }
 
-        private void DebugIncreaseReheatCounter()
-        {
-            var reheats = new IntValue(0);
-            var frozen = new ItemList<DoubleValue>();
-            var results = (ResultCollection)ExecutionContext.Parent.Parent.Scope.Variables[ResultsName].Value;
-            IResult amountOfReheats;
-            IResult frozenSolutions;
-            if (results.TryGetValue(AmountOfReheatsName, out amountOfReheats))
-            {
-                reheats = (IntValue)amountOfReheats.Value;
-                reheats.Value += 1;
-            }
-            else
-            {
-                reheats.Value += 1;
-                results.Add(new Result(AmountOfReheatsName, reheats));
-            }
-
-            if (results.TryGetValue(QualitiesBeforeReheatingName, out frozenSolutions))
-            {
-                
-                frozen = (ItemList<DoubleValue>) frozenSolutions.Value;
-                frozen.Add(new DoubleValue(LastAcceptedQualityParameter.ActualValue.Value));
-            }
-            else
-            {
-                frozen.Add(new DoubleValue(LastAcceptedQualityParameter.ActualValue.Value));
-                results.Add(new Result(QualitiesBeforeReheatingName, frozen));
-            }
-        }
-
         private IOperation Heat()
         {
@@ -293,5 +212,4 @@
         private IOperation Cool()
         {
-            TemperatureBeforeReheatParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
             return new OperationCollection {
                     ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingMainLoop.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingMainLoop.cs	(revision 15332)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingMainLoop.cs	(revision 15333)
@@ -64,7 +64,5 @@
         private const string LastQualityName = "LastQuality";
         private const string UphillMovesMemoryName = "UphillMovesMemory";
-        private const string TemperatureBeforeReheatName = "TemperatureBeforeReheat";
         private const string CurrentRandomWalkStepName = "CurrentRandomWalkStep";
-        private const string QualitiesBeforeReheatingName = "QualitiesBeforeReheating";
         private const string LastAcceptedQualityName = "LastAcceptedQuality";
         private const string TemperatureInitializerName = "TemperatureInitializer";
@@ -247,6 +245,4 @@
             variableCreator.CollectedValues.Add(new ValueParameter<ItemList<DoubleValue>>(UphillMovesMemoryName, new ItemList<DoubleValue>()));
             variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(CurrentRandomWalkStepName, new IntValue(0)));
-            variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(TemperatureBeforeReheatName, new DoubleValue(0)));
-            variableCreator.CollectedValues.Add(new ValueParameter<ItemList<DoubleValue>>(QualitiesBeforeReheatingName, new ItemList<DoubleValue>()));
             variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(LastAcceptedQualityName, new DoubleValue(-1)));
 
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureController.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureController.cs	(revision 15332)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureController.cs	(revision 15333)
@@ -58,7 +58,5 @@
         private const string MaximizationName = "Maximization";
         private const string MoveQualityName = "MoveQuality";
-        private const string TemperatureBeforeReheatName = "TemperatureBeforeReheat";
         private const string CurrentRandomWalkStepName = "CurrentRandomWalkStep";
-        private const string QualitiesBeforeReheatingName = "QualitiesBeforeReheating";
         private const string LastAcceptedQualityName = "LastAcceptedQuality";
         private const string TemperatureInitializerName = "TemperatureInitializer";
@@ -92,5 +90,5 @@
             Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
             Parameters.Add(new ValueLookupParameter<BoolValue>(MaximizationName, "True if the problem is a maximization problem, otherwise false."));
-            Parameters.Add(new ValueLookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new ValueLookupParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator that cools the temperature."));
             Parameters.Add(new ValueLookupParameter<IReheatingOperator>(ReheatingOperatorName, "The operator that reheats the temperature if necessary."));
             Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
@@ -108,6 +106,4 @@
             Parameters.Add(new LookupParameter<DoubleValue>(AverageAcceptanceRatioName, "Average acceptance over full acceptance memory."));
             Parameters.Add(new LookupParameter<IntValue>(CurrentRandomWalkStepName, "Current random walk step."));
-            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureBeforeReheatName, "Temperature before the reheat occured."));
-            Parameters.Add(new LookupParameter<ItemList<DoubleValue>>(QualitiesBeforeReheatingName, "List of qualities where the algorithm has been stuck."));
             Parameters.Add(new LookupParameter<DoubleValue>(LastAcceptedQualityName, "Quality of last accepted solution."));
 
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureInitializerBasedOnAverageHillsize.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureInitializerBasedOnAverageHillsize.cs	(revision 15332)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureInitializerBasedOnAverageHillsize.cs	(revision 15333)
@@ -110,5 +110,5 @@
             Parameters.Add(new ValueLookupParameter<BoolValue>(MaximizationName, "True if the problem is a maximization problem, otherwise false."));
             Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
-            Parameters.Add(new ValueParameter<DoubleValue>(InitialAcceptanceRateName, "The initial acceptance rate of average-sized hills used to calculate the initial temperature.", new DoubleValue(0.001)));
+            Parameters.Add(new ValueParameter<DoubleValue>(InitialAcceptanceRateName, "The initial acceptance rate of average-sized hills used to calculate the initial temperature.", new DoubleValue(0.1)));
             Parameters.Add(new ValueParameter<IntValue>(UphillMovesMemorySizeName, "The amount of uphill moves necessary to compute the initial temperature.", new IntValue(100)));
             Parameters.Add(new LookupParameter<ItemList<DoubleValue>>(UphillMovesMemoryName, "The field that stores the uphill moves."));
