Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs	(revision 15314)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs	(revision 15315)
@@ -16,5 +16,5 @@
 namespace HeuristicLab.Algorithms.SimulatedAnnealing
 {
-    [Item("AcceptanceRatioReheatingOperator", "Reheats the temperature if the acceptance is below a threshold.")]
+    [Item("AcceptanceRatioReheatingOperator", "Reheats the temperature if the acceptance is below a threshold until it is above another one.")]
     [StorableClass]
     public class AcceptanceRatioReheatingOperator : SingleSuccessorOperator, IReheatingOperator
@@ -38,4 +38,5 @@
         private const string AcceptanceMemoryName = "AcceptanceMemory";
         private const string AverageAcceptanceRatioName = "AverageAcceptanceRatio";
+        private const string ReheatWindowSizeName = "ReheatWindowSize";
 
 
@@ -105,4 +106,8 @@
         {
             get { return (ILookupParameter<DoubleValue>)Parameters[AverageAcceptanceRatioName]; }
+        }
+        public IValueParameter<IntValue> ReheatWindowSizeParameter
+        {
+            get { return (IValueParameter<IntValue>)Parameters[ReheatWindowSizeName]; }
         }
 
@@ -128,4 +133,5 @@
             Parameters.Add(new ValueParameter<IntValue>(MemorySizeName, "The maximum size of the acceptance memory.", new IntValue(100)));
             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)));
             #endregion
 
@@ -204,4 +210,6 @@
                     StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
                     EndTemperatureParameter.ActualValue.Value = UpperTemperatureParameter.ActualValue.Value;
+                    ReheatingOperatorParameter.Value.EndIndexParameter.Value = new IntValue(
+                        Math.Min(MaximumIterationsParameter.ActualValue.Value, IterationsParameter.ActualValue.Value + ReheatWindowSizeParameter.Value.Value));
                 }
 
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs	(revision 15314)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs	(revision 15315)
@@ -16,5 +16,5 @@
 namespace HeuristicLab.Algorithms.SimulatedAnnealing
 {
-    [Item("ConsecutiveRejectionTemperatureResetOperator", "The operator resets the temperature to X when N consecutive solutions are rejected. X is calculated by BaseResetTemperature * (MultiplyWithEachReheat to the power of the current number of reheats).")]
+    [Item("ConsecutiveRejectionTemperatureResetOperator", "The operator resets the temperature to the ResetTemperature when N consecutive solutions are rejected.")]
     [StorableClass]
     public class ConsecutiveRejectionTemperatureResetOperator : SingleSuccessorOperator, IReheatingOperator
@@ -34,11 +34,11 @@
         private const string IsAcceptedName = "IsAccepted";
         private const string ConsecutiveRejectedSolutionsCountName = "ConsecutiveRejectedSolutions";
-        private const string BaseResetTemperatureName = "BaseResetTemperature";
+        private const string ResetTemperatureName = "ResetTemperature";
         #endregion
 
         #region Parameters
-        private ValueLookupParameter<DoubleValue> BaseResetTemperatureParameter
+        private ValueLookupParameter<DoubleValue> ResetTemperatureParameter
         {
-            get { return (ValueLookupParameter<DoubleValue>)Parameters[BaseResetTemperatureName]; }
+            get { return (ValueLookupParameter<DoubleValue>)Parameters[ResetTemperatureName]; }
         }
         public ILookupParameter<DoubleValue> TemperatureParameter
@@ -102,5 +102,5 @@
             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 ValueLookupParameter<DoubleValue>(BaseResetTemperatureName, "The base reset temperature.", InitialTemperatureName));
+            Parameters.Add(new ValueLookupParameter<DoubleValue>(ResetTemperatureName, "The base reset temperature.", InitialTemperatureName));
           
             #endregion
@@ -138,5 +138,5 @@
         private IOperation Heat()
         {
-            var temperature = Math.Max(BaseResetTemperatureParameter.ActualValue.Value, TemperatureParameter.ActualValue.Value);
+            var temperature = Math.Max(ResetTemperatureParameter.ActualValue.Value, TemperatureParameter.ActualValue.Value);
 
             TemperatureParameter.ActualValue.Value = temperature;
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ITemperatureInitializer.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ITemperatureInitializer.cs	(revision 15315)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ITemperatureInitializer.cs	(revision 15315)
@@ -0,0 +1,13 @@
+﻿using HeuristicLab.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    public interface ITemperatureInitializer : IOperator
+    {
+    }
+}
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/RandomWalkReheatingOperator.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/RandomWalkReheatingOperator.cs	(revision 15315)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/RandomWalkReheatingOperator.cs	(revision 15315)
@@ -0,0 +1,302 @@
+﻿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("RandomWalkReheatingOperator", "Performs a randomwalk with the lenght of n after x consecutive solutions were rejected.")]
+    [StorableClass]
+    public class RandomWalkReheatingOperator : 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 TemperatureBeforeReheatName = "TemperatureBeforeReheat";
+        private const string CurrentRandomWalkStepName = "CurrentRandomWalkStep";
+        private const string RandomWalkLengthName = "RandomWalkLength";
+        private const string ThresholdName = "Threshold";
+        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";
+
+
+        #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<IOperator> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        }
+        public ILookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        private ValueParameter<IntValue> ThresholdParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[ThresholdName]; }
+        }
+        private ValueParameter<IntValue> RandomWalkLengthParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[RandomWalkLengthName]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<IntValue> ConsecutiveRejectedSolutionsCountParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[ConsecutiveRejectedSolutionsCountName]; }
+        }
+        public ILookupParameter<IntValue> RandomWalkLengthNameParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[RandomWalkLengthName]; }
+        }
+        public ILookupParameter<IntValue> CurrentRandomWalkStepParameter
+        {
+            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
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[CoolingName]; }
+        }
+        public ILookupParameter<DoubleValue> MoveQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> LastAcceptedQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LastAcceptedQualityName]; }
+        }
+        public IValueParameter<BoolValue> TabuListActiveParameter
+        {
+            get { return (IValueParameter<BoolValue>)Parameters[TabuListActiveName];  }
+        }
+
+        #endregion
+
+        public RandomWalkReheatingOperator() : 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<IOperator>(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."));
+            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<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 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
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected RandomWalkReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected RandomWalkReheatingOperator(RandomWalkReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new RandomWalkReheatingOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+        }
+
+        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)
+            {
+                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()
+        {
+            TemperatureParameter.ActualValue.Value = Double.PositiveInfinity;
+            return base.Apply();
+        }
+
+        private IOperation Cool()
+        {
+            TemperatureBeforeReheatParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+    }
+}
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealing.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealing.cs	(revision 15314)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealing.cs	(revision 15315)
@@ -51,5 +51,4 @@
         private const string MaximumIterationsName = "MaximumIterations";
         private const string InitialTemperatureName = "InitialTemperature";
-        private const string InitialAcceptanceRateName = "InitialAcceptanceRate";
         private const string LowerTemperatureName = "LowerTemperature";
         private const string AnalyzerName = "Analyzer";
@@ -65,4 +64,5 @@
         private const string TemperatureChartName = "Temperature Chart";
         private const string TemperatureAnalyzerName = "Temperature Analyzer";
+        private const string TemperatureInitializerName = "TemperatureInitializer";
         #endregion
 
@@ -111,12 +111,12 @@
             get { return (IConstrainedValueParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
         }
+        public IConstrainedValueParameter<ITemperatureInitializer> TemperatureInitializerParameter
+        {
+            get { return (IConstrainedValueParameter<ITemperatureInitializer>)Parameters[TemperatureInitializerName]; }
+        }
 
         private ValueParameter<IntValue> MaximumIterationsParameter
         {
             get { return (ValueParameter<IntValue>)Parameters[MaximumIterationsName]; }
-        }
-        private ValueParameter<DoubleValue> InitialAcceptanceRateParameter
-        {
-            get { return (ValueParameter<DoubleValue>)Parameters[InitialAcceptanceRateName]; }
         }
         private ValueParameter<DoubleValue> LowerTemperatureParameter
@@ -167,4 +167,9 @@
             set { ReheatingOperatorParameter.Value = value; }
         }
+        public ITemperatureInitializer TemperatureInitializer
+        {
+            get { return TemperatureInitializerParameter.Value; }
+            set { TemperatureInitializerParameter.Value = value; }
+        }
 
         public IntValue MaximumIterations
@@ -172,9 +177,4 @@
             get { return MaximumIterationsParameter.Value; }
             set { MaximumIterationsParameter.Value = value; }
-        }
-        public DoubleValue InitialAcceptanceRate
-        {
-            get { return InitialAcceptanceRateParameter.Value; }
-            set { InitialAcceptanceRateParameter.Value = value; }
         }
         public DoubleValue LowerTemperature
@@ -219,6 +219,6 @@
             Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator used to cool the temperature."));
             Parameters.Add(new ConstrainedValueParameter<IReheatingOperator>(ReheatingOperatorName, "The operator used to reheat the temperature, if necessary."));
+            Parameters.Add(new ConstrainedValueParameter<ITemperatureInitializer>(TemperatureInitializerName, "The operator used to initialize the temperature."));
             Parameters.Add(new ValueParameter<IntValue>(MaximumIterationsName, "The maximum number of generations which should be processed.", new IntValue(10000)));
-            Parameters.Add(new ValueParameter<DoubleValue>(InitialAcceptanceRateName, "The initial acceptance rate of average-sized hills used to calculate the initial temperature", new DoubleValue(0.4)));
             Parameters.Add(new ValueParameter<DoubleValue>(LowerTemperatureName, "The lower bound for the temperature.", new DoubleValue(1e-6)));
             Parameters.Add(new ValueParameter<MultiAnalyzer>(AnalyzerName, "The operator used to analyze each iteration.", new MultiAnalyzer()));
@@ -300,4 +300,9 @@
             {
                 AnnealingOperatorParameter.ValidValues.Add(op);
+            }
+
+            foreach(var op in ApplicationManager.Manager.GetInstances<ITemperatureInitializer>().OrderBy(x => x.Name))
+            {
+                TemperatureInitializerParameter.ValidValues.Add(op);
             }
 
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingMainLoop.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingMainLoop.cs	(revision 15314)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingMainLoop.cs	(revision 15315)
@@ -49,5 +49,4 @@
         private const string CoolingName = "Cooling";
         private const string InitialTemperatureName = "InitialTemperature";
-        private const string InitialAcceptanceRateName = "InitialAcceptanceRate";
         private const string StartTemperatureName = "StartTemperature";
         private const string EndTemperatureName = "EndTemperature";
@@ -65,4 +64,11 @@
         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";
+        private const string TemperatureInitializedName = "TemperatureInitialized";
+
         #endregion
 
@@ -91,8 +97,4 @@
         {
             get { return (ILookupParameter<DoubleValue>)Parameters[InitialTemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> InitialAcceptanceRateParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[InitialAcceptanceRateName]; }
         }
         public ILookupParameter<DoubleValue> MoveQualityParameter
@@ -200,4 +202,5 @@
             Parameters.Add(new ValueLookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
             Parameters.Add(new ValueLookupParameter<IOperator>(ReheatingOperatorName, "The operator that reheats the temperature if necessary."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(TemperatureInitializerName, "The operator that initialized the temperature."));
 
             Parameters.Add(new ValueLookupParameter<IOperator>(AnalyzerName, "The operator used to analyze each generation."));
@@ -206,9 +209,9 @@
 
             Parameters.Add(new LookupParameter<DoubleValue>(InitialTemperatureName, "The initial temperature."));
-            Parameters.Add(new LookupParameter<DoubleValue>(InitialAcceptanceRateName, "The initial acceptance rate of average-sized hills used to calculate the initial temperature."));
             Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
             Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
             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."));
+
 
             #endregion
@@ -237,4 +240,5 @@
 
             variableCreator.Name = "Initialize Memory";
+            variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>(TemperatureInitializedName, new BoolValue(false)));
             variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(AverageAcceptanceRatioName, new DoubleValue(0d)));
             variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(ConsecutiveRejectedSolutionsCountName, new IntValue(0)));
@@ -242,4 +246,8 @@
             variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(LastQualityName, new DoubleValue(-1)));
             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)));
 
             analyzer1.Name = "Analyzer";
@@ -267,5 +275,4 @@
 
            
-
             subScopesRemover.RemoveAllSubScopes = true;
 
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureController.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureController.cs	(revision 15314)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureController.cs	(revision 15315)
@@ -34,5 +34,5 @@
 namespace HeuristicLab.Algorithms.SimulatedAnnealing
 {
-    [Item("TemperatureController", "Decides based on information from the heatingoperator, whether to use cooling or heating and calls the appropriate operator.")]
+    [Item("TemperatureController", "Responsible to first initialize the temperature and then control the temperature.")]
     [StorableClass]
     public class TemperatureController : SingleSuccessorOperator
@@ -58,90 +58,24 @@
         private const string MaximizationName = "Maximization";
         private const string MoveQualityName = "MoveQuality";
-        private const string InitialAcceptanceRateName = "InitialAcceptanceRate";
-        private const string ResultsName = "Results";
-        private const string CalculatedInitialTemperatureName = "CalculatedInitialTemperature";
-
+        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";
+        private const string TemperatureInitializedName = "TemperatureInitialized";
         #endregion
 
         #region Parameter Properties
-        public ILookupParameter<DoubleValue> TemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> InitialTemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[InitialTemperatureName]; }
-        }
-        public IValueLookupParameter<DoubleValue> LowerTemperatureParameter
-        {
-            get { return (IValueLookupParameter<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<BoolValue> CoolingParameter
-        {
-            get { return (ILookupParameter<BoolValue>)Parameters[CoolingName]; }
-        }
-        public ILookupParameter<IntValue> IterationsParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
-        }
-        public IValueLookupParameter<IntValue> MaximumIterationsParameter
-        {
-            get { return (IValueLookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
-        }
-        public IValueLookupParameter<IOperator> AnnealingOperatorParameter
-        {
-            get { return (IValueLookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
-        }
         public IValueLookupParameter<IReheatingOperator> ReheatingOperatorParameter
         {
             get { return (IValueLookupParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
         }
-        public ILookupParameter<BoolValue> IsAcceptedParameter
+        public IValueLookupParameter<ITemperatureInitializer> TemperatureInitializerParameter
         {
-            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+            get { return (IValueLookupParameter<ITemperatureInitializer>)Parameters[TemperatureInitializerName]; }
         }
-        public ILookupParameter<ItemList<BoolValue>> AcceptanceMemoryParameter
+        public ILookupParameter<BoolValue> TemperatureInitializedParameter
         {
-            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
-        }
-        public ILookupParameter<ItemList<DoubleValue>> UphillMovesMemoryParameter
-        {
-            get { return (ILookupParameter<ItemList<DoubleValue>>)Parameters[UphillMovesMemoryName]; }
-        }
-        public ILookupParameter<DoubleValue> MoveQualityParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
-        }
-        public ILookupParameter<DoubleValue> LastQualityParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[LastQualityName]; }
-        }
-        public IValueLookupParameter<BoolValue> MaximizationParameter
-        {
-            get { return (IValueLookupParameter<BoolValue>)Parameters[MaximizationName]; }
-        }
-        public ILookupParameter<DoubleValue> InitialAcceptanceRateParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[InitialAcceptanceRateName]; }
-        }
-        public ILookupParameter<IntValue> ConsecutiveRejectedSolutionsCountParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[ConsecutiveRejectedSolutionsCountName]; }
-        }
-        public ILookupParameter<DoubleValue> AverageAcceptanceRatioParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[AverageAcceptanceRatioName]; }
+            get { return (ILookupParameter<BoolValue>)Parameters[TemperatureInitializedName]; }
         }
         #endregion
@@ -171,7 +105,13 @@
             Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
             Parameters.Add(new LookupParameter<DoubleValue>(LastQualityName, "The value which represents the quality of the last move."));
-            Parameters.Add(new LookupParameter<DoubleValue>(InitialAcceptanceRateName, "The initial acceptance rate of average-sized hills used to calculate the initial temperature."));
             Parameters.Add(new LookupParameter<IntValue>(ConsecutiveRejectedSolutionsCountName, "Amount of consecutive rejected solutions."));
             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."));
+
+            Parameters.Add(new ValueLookupParameter<ITemperatureInitializer>(TemperatureInitializerName, "The operator that initilized the temperature."));
+            Parameters.Add(new LookupParameter<BoolValue>(TemperatureInitializedName, "True, if the temperature has already been initialized."));
 
         }
@@ -184,9 +124,14 @@
         public override IOperation Apply()
         {
-            var uphillMoves = UphillMovesMemoryParameter.ActualValue;
-            if (!InitialTemperatureFound())
+
+            if (!TemperatureInitializedParameter.ActualValue.Value)
             {
-                return findInitialTemperature();
-            }else
+                return new OperationCollection
+                {
+                    ExecutionContext.CreateOperation(TemperatureInitializerParameter.ActualValue),
+                    base.Apply()
+                };
+            }
+            else
             {
                 return new OperationCollection {
@@ -196,52 +141,4 @@
             }
         }
-
-        private IOperation findInitialTemperature()
-        {
-            var currentQuality = MoveQualityParameter.ActualValue.Value;
-            var lastQuality = LastQualityParameter.ActualValue.Value;
-            var isMaximation = MaximizationParameter.ActualValue.Value;
-            var hillMemory = UphillMovesMemoryParameter.ActualValue;
-            
-            if(lastQuality != -1)
-            {
-                double hillSize = CalculateHillSize(lastQuality, currentQuality, isMaximation);
-                
-                if(hillSize > 0)
-                {
-                    hillMemory.Add(new DoubleValue(hillSize));
-                    if(InitialTemperatureFound())
-                    {
-                        var results = (ResultCollection)ExecutionContext.Parent.Scope.Variables[ResultsName].Value;
-                        var initialTemperature = CalculateInitialTemperatureBasedOnAverageHillSize(hillMemory);
-                        InitialTemperatureParameter.ActualValue.Value = initialTemperature;
-                        TemperatureParameter.ActualValue.Value = initialTemperature;
-                        TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
-                        StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
-                        results.Add(new Result(CalculatedInitialTemperatureName, new DoubleValue(initialTemperature)));
-                    }
-                }
-            }
-
-            LastQualityParameter.ActualValue.Value = currentQuality;
-            return base.Apply();
-        }
-
-        private double CalculateInitialTemperatureBasedOnAverageHillSize(ItemList<DoubleValue> hillMemory)
-        {
-            var averageHillSize = hillMemory.Average(x => x.Value);
-            return -(averageHillSize / Math.Log(InitialAcceptanceRateParameter.ActualValue.Value));
-
-        }
-
-        private double CalculateHillSize(double lastQuality, double currentQuality, bool isMaximation)
-        {
-            return isMaximation ? lastQuality - currentQuality : currentQuality - lastQuality;
-        }
-
-        private bool InitialTemperatureFound()
-        {
-            return UphillMovesMemoryParameter.ActualValue.Count == 100;
-        }
     }
 }
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureInitializerBasedOnAverageHillsize.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureInitializerBasedOnAverageHillsize.cs	(revision 15315)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureInitializerBasedOnAverageHillsize.cs	(revision 15315)
@@ -0,0 +1,178 @@
+﻿using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    /*  Temperature initializer based on Johnson, David S., et al. "Optimization by simulated annealing: an experimental evaluation; part I, graph partitioning." Operations research 37.6 (1989): 865-892.
+     *  http://faculty.washington.edu/aragon/pubs/annealing-pt1.pdf (see Section 5.4, Paragraph 3, Parameter INITPROB)
+     *  
+     *  The initial temperature gets calculated by
+     *      1. Performing a random walk and collection of (UphillMovesMemorySize) amount of hills
+     *      2. Calculating the average hillsize
+     *      3. Define initial temperature as the temperature that lets the algorithm overcome a hill of average size with a percentage of INITIALACCEPTANCERATE
+     */
+
+    [Item("TemperatureInitializerBasedOnAverageHillsize", "Sets the initial temperature to the temperature that initialy lets the algorithm accept an averaged sized hill with a certain probability.")]
+    [StorableClass]
+    public class TemperatureInitializerBasedOnAverageHillsize : SingleSuccessorOperator, ITemperatureInitializer
+    {
+        #region Strings
+        private const string InitialTemperatureName = "InitialTemperature";
+        private const string TemperatureInitializedName = "TemperatureInitialized";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string TemperatureName = "Temperature";
+        private const string IterationsName = "Iterations";
+
+        private const string LastQualityName = "LastQuality";
+        private const string UphillMovesMemoryName = "UphillMovesMemory";
+        private const string UphillMovesMemorySizeName = "UphillMovesMemorySize";
+        private const string MaximizationName = "Maximization";
+        private const string MoveQualityName = "MoveQuality";
+        private const string InitialAcceptanceRateName = "InitialAcceptanceRate";
+
+        private const string ResultsName = "Results";
+
+
+        #endregion
+
+        #region Properties
+        public ILookupParameter<DoubleValue> InitialTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[InitialTemperatureName]; }
+        }
+        public ILookupParameter<BoolValue> TemperatureInitializedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[TemperatureInitializedName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public ILookupParameter<ItemList<DoubleValue>> UphillMovesMemoryParameter
+        {
+            get { return (ILookupParameter<ItemList<DoubleValue>>)Parameters[UphillMovesMemoryName]; }
+        }
+        public ILookupParameter<DoubleValue> MoveQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> LastQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LastQualityName]; }
+        }
+        public IValueLookupParameter<BoolValue> MaximizationParameter
+        {
+            get { return (IValueLookupParameter<BoolValue>)Parameters[MaximizationName]; }
+        }
+        public IValueParameter<DoubleValue> InitialAcceptanceRateParameter
+        {
+            get { return (IValueParameter<DoubleValue>)Parameters[InitialAcceptanceRateName]; }
+        }
+        public IValueParameter<IntValue> UphillMovesMemorySizeParameter
+        {
+            get { return (IValueParameter<IntValue>)Parameters[UphillMovesMemorySizeName]; }
+        }
+
+        #endregion
+
+        public TemperatureInitializerBasedOnAverageHillsize() : base()
+        {
+            Parameters.Add(new LookupParameter<DoubleValue>(InitialTemperatureName, "Temporary initial temperature field."));
+            Parameters.Add(new LookupParameter<BoolValue>(TemperatureInitializedName, "True, if the temperature has already been initialized."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
+            Parameters.Add(new LookupParameter<DoubleValue>(LastQualityName, "The value which represents the quality of the last move."));
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            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<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."));
+        }
+
+        [StorableConstructor]
+        protected TemperatureInitializerBasedOnAverageHillsize(bool deserializing) : base(deserializing) { }
+        protected TemperatureInitializerBasedOnAverageHillsize(TemperatureInitializerBasedOnAverageHillsize original, Cloner cloner) : base(original, cloner) { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new TemperatureInitializerBasedOnAverageHillsize(this, cloner);
+        }
+
+        public override IOperation Apply()
+        {
+            var currentQuality = MoveQualityParameter.ActualValue.Value;
+            var lastQuality = LastQualityParameter.ActualValue.Value;
+            var isMaximation = MaximizationParameter.ActualValue.Value;
+            var hillMemory = UphillMovesMemoryParameter.ActualValue;
+
+            if (lastQuality != -1)
+            {
+                double hillSize = CalculateHillSize(lastQuality, currentQuality, isMaximation);
+                
+                // if there was an uphill move
+                if (hillSize > 0)
+                {
+                    // add it to the list
+                    hillMemory.Add(new DoubleValue(hillSize));
+                    
+                    // if enough hills have been collected
+                    if (hillMemory.Count >= UphillMovesMemorySizeParameter.Value.Value)
+                    {
+                        // calculate and set initial temperature
+                        var initialTemperature = CalculateInitialTemperatureBasedOnAverageHillSize(hillMemory);
+                        InitialTemperatureParameter.ActualValue.Value = initialTemperature;
+                        TemperatureParameter.ActualValue.Value = initialTemperature;
+                        TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+                        StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+
+                        var results = (ResultCollection)ExecutionContext.Parent.Scope.Variables[ResultsName].Value;
+                        results.Add(new Result(InitialTemperatureName, new DoubleValue(initialTemperature)));
+
+                        // indicate that initial temperature is now set
+                        TemperatureInitializedParameter.ActualValue.Value = true;
+                    }
+                }
+            }
+
+            LastQualityParameter.ActualValue.Value = currentQuality;
+            return base.Apply();
+        }
+
+        private double CalculateInitialTemperatureBasedOnAverageHillSize(ItemList<DoubleValue> hillMemory)
+        {
+            var averageHillSize = hillMemory.Average(x => x.Value);
+            return -(averageHillSize / Math.Log(InitialAcceptanceRateParameter.Value.Value));
+
+        }
+
+        private double CalculateHillSize(double lastQuality, double currentQuality, bool isMaximation)
+        {
+            return isMaximation ? lastQuality - currentQuality : currentQuality - lastQuality;
+        }
+    }
+}
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ValueTemperatureInitializer.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ValueTemperatureInitializer.cs	(revision 15315)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ValueTemperatureInitializer.cs	(revision 15315)
@@ -0,0 +1,96 @@
+﻿using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("BasicTemperatureInitializer", "Sets the initial temperature to a fixed value.")]
+    [StorableClass]
+    public class BasicTemperatureInitializer : SingleSuccessorOperator, ITemperatureInitializer
+    {
+        #region Strings
+        private const string InitialTemperatureName = "InitialTemperature";
+        private const string TemperatureInitializedName = "TemperatureInitialized";
+        private const string InitialTemperatureSetterName = "InitialTemperatureValue";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string TemperatureName = "Temperature";
+        private const string IterationsName = "Iterations";
+        #endregion
+
+        #region Properties
+        public ILookupParameter<DoubleValue> InitialTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[InitialTemperatureName]; }
+        }
+        public ILookupParameter<BoolValue> TemperatureInitializedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[TemperatureInitializedName]; }
+        }
+        public IValueParameter<DoubleValue> InitialTemperatureSetterParameter
+        {
+            get { return (IValueParameter<DoubleValue>)Parameters[InitialTemperatureSetterName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+
+        #endregion
+
+        public BasicTemperatureInitializer() : base()
+        {
+            Parameters.Add(new LookupParameter<DoubleValue>(InitialTemperatureName, "Temporary initial temperature field."));
+            Parameters.Add(new ValueParameter<DoubleValue>(InitialTemperatureSetterName, "Sets the initial temperature to this value", new DoubleValue(100)));
+            Parameters.Add(new LookupParameter<BoolValue>(TemperatureInitializedName, "True, if the temperature has already been initialized."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+        }
+
+        [StorableConstructor]
+        protected BasicTemperatureInitializer(bool deserializing) : base(deserializing) { }
+        protected BasicTemperatureInitializer(BasicTemperatureInitializer original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new BasicTemperatureInitializer(this, cloner);
+        }
+
+        public override IOperation Apply()
+        {
+            // set temperature to selected value
+            InitialTemperatureParameter.ActualValue.Value = InitialTemperatureSetterParameter.Value.Value;
+            TemperatureParameter.ActualValue.Value = InitialTemperatureSetterParameter.Value.Value;
+            TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+            StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+
+            // indicate that initial temperature is now set
+            TemperatureInitializedParameter.ActualValue.Value = true;
+
+            return base.Apply();
+        }
+    }
+}
