Index: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/AcceptanceRatioReheatingOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/AcceptanceRatioReheatingOperator.cs	(revision 15295)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/AcceptanceRatioReheatingOperator.cs	(revision 15295)
@@ -0,0 +1,229 @@
+﻿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("AcceptanceRatioReheatingOperator", "Reheats the temperature if the acceptance is below a threshold until it is above another one.")]
+    [StorableClass]
+    public class AcceptanceRatioReheatingOperator : 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 UpperTemperatureName = "UpperTemperature";
+        private const string ReheatingOperatorName = "ReheatingOperator";
+        private const string ThresholdName = "Threshold";
+        private const string MemorySizeName = "MemorySize";
+        private const string CoolingName = "Cooling";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string AverageAcceptanceRatioName = "AverageAcceptanceRatio";
+
+
+        #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 ValueLookupParameter<DoubleValue> UpperTemperatureParameter
+        {
+            get { return (ValueLookupParameter<DoubleValue>)Parameters[UpperTemperatureName]; }
+        }
+        private IConstrainedValueParameter<IDiscreteDoubleValueModifier> ReheatingOperatorParameter
+        {
+            get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters[ReheatingOperatorName]; }
+        }
+        private ValueParameter<DoubleRange> ThresholdParameter
+        {
+            get { return (ValueParameter<DoubleRange>)Parameters[ThresholdName]; }
+        }
+        private ValueParameter<IntValue> MemorySizeParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[MemorySizeName]; }
+        }
+        public ILookupParameter<BoolValue> CoolingParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[CoolingName]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<ItemList<BoolValue>> AcceptanceMemoryParameter
+        {
+            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
+        }
+        public ILookupParameter<DoubleValue> AverageAcceptanceRatioParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[AverageAcceptanceRatioName]; }
+        }
+
+        #endregion
+
+        public AcceptanceRatioReheatingOperator() : 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<ItemList<BoolValue>>(AcceptanceMemoryName, "Memorizes the last N acceptance decisions."));
+            Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
+            Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperTemperatureName, "The upper bound of the temperature.", "InitialTemperature"));
+            Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>(ReheatingOperatorName, "The operator that reheats the temperature."));
+            Parameters.Add(new ValueParameter<DoubleRange>(ThresholdName, "The threshold controls the temperature. If the average ratio of accepted moves goes below the start of the range the temperature is heated. If the the average ratio of accepted moves goes beyond the end of the range the temperature is cooled again.", new DoubleRange(0.01, 0.1)));
+            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."));
+            #endregion
+
+            foreach (var op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
+            {
+                ReheatingOperatorParameter.ValidValues.Add((IDiscreteDoubleValueModifier) op);
+            }
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected AcceptanceRatioReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected AcceptanceRatioReheatingOperator(AcceptanceRatioReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new AcceptanceRatioReheatingOperator(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.ActualName = EndTemperatureName;
+                op.EndValueParameter.Hidden = true;
+            }
+        }
+
+        public override IOperation Apply()
+        {
+            var isAccepted = IsAcceptedParameter.ActualValue;
+            var acceptances = AcceptanceMemoryParameter.ActualValue;
+            var cooling = CoolingParameter.ActualValue.Value;
+            var ratioAmount = AverageAcceptanceRatioParameter.ActualValue;
+
+            acceptances.Add(isAccepted);
+
+            ratioAmount.Value += isAccepted.Value ? 1 : 0;
+
+
+            if (acceptances.Count > MemorySizeParameter.Value.Value) {
+                ratioAmount.Value -= acceptances.ElementAt(0).Value ? 1 : 0;
+                acceptances.RemoveAt(0);
+            }
+
+            // only reheat when at least MemorySizeParameter.Value iterations have passed
+            if (acceptances.Count == MemorySizeParameter.Value.Value)
+            {
+                var ratio = ratioAmount.Value / MemorySizeParameter.Value.Value;
+                var ratioStart = ThresholdParameter.Value.Start;
+                var ratioEnd = ThresholdParameter.Value.End;
+
+                if (!cooling && ratio >= ratioEnd)
+                {
+                    // if we are heating, but should be cooling
+                    cooling = true;
+                    TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+                    StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+                    EndTemperatureParameter.ActualValue.Value = LowerTemperatureParameter.ActualValue.Value;
+                }
+                else if (cooling && ratio <= ratioStart)
+                {
+                    // if we are cooling but should be heating
+                    cooling = false;
+                    TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+                    StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+                    EndTemperatureParameter.ActualValue.Value = UpperTemperatureParameter.ActualValue.Value;
+                }
+
+                CoolingParameter.ActualValue.Value = cooling;
+            }
+            return cooling ? Cool() : Heat();
+        }
+
+        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: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ConsecutiveRejectionTemperatureResetOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ConsecutiveRejectionTemperatureResetOperator.cs	(revision 15295)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ConsecutiveRejectionTemperatureResetOperator.cs	(revision 15295)
@@ -0,0 +1,156 @@
+﻿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("ConsecutiveRejectionTemperatureResetOperator", "The operator resets the temperature to the ResetTemperature when N consecutive solutions are rejected.")]
+    [StorableClass]
+    public class ConsecutiveRejectionTemperatureResetOperator : 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 ThresholdName = "Threshold";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string ConsecutiveRejectedSolutionsCountName = "ConsecutiveRejectedSolutions";
+        private const string ResetTemperatureName = "ResetTemperature";
+        #endregion
+
+        #region Parameters
+        private ValueLookupParameter<DoubleValue> ResetTemperatureParameter
+        {
+            get { return (ValueLookupParameter<DoubleValue>)Parameters[ResetTemperatureName]; }
+        }
+        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]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<IntValue> ConsecutiveRejectedSolutionsCountParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[ConsecutiveRejectedSolutionsCountName]; }
+        }
+        #endregion
+
+        public ConsecutiveRejectionTemperatureResetOperator() : 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 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<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>(ResetTemperatureName, "The base reset temperature.", InitialTemperatureName));
+          
+            #endregion
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected ConsecutiveRejectionTemperatureResetOperator(bool deserializing) : base(deserializing) { }
+        protected ConsecutiveRejectionTemperatureResetOperator(ConsecutiveRejectionTemperatureResetOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ConsecutiveRejectionTemperatureResetOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+        }
+
+        public override IOperation Apply()
+        {
+            var count = ConsecutiveRejectedSolutionsCountParameter.ActualValue;
+
+            count.Value = !IsAcceptedParameter.ActualValue.Value ? count.Value + 1 : 0;
+
+            var heating = count.Value == ThresholdParameter.Value.Value;
+
+            if(heating) count.Value = 0;
+
+            return heating ? Heat() : Cool();
+        }
+
+        private IOperation Heat()
+        {
+            var temperature = Math.Max(ResetTemperatureParameter.ActualValue.Value, TemperatureParameter.ActualValue.Value);
+
+            TemperatureParameter.ActualValue.Value = temperature;
+            TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+            StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+            return base.Apply();
+        }
+
+        private IOperation Cool()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/IReheatingOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/IReheatingOperator.cs	(revision 15295)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/IReheatingOperator.cs	(revision 15295)
@@ -0,0 +1,15 @@
+﻿using HeuristicLab.Core;
+using HeuristicLab.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    public interface IReheatingOperator : IOperator
+    {
+        void Parameterize();
+    }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ITemperatureInitializer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ITemperatureInitializer.cs	(revision 15295)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ITemperatureInitializer.cs	(revision 15295)
@@ -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: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/NoReheatingOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/NoReheatingOperator.cs	(revision 15295)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/NoReheatingOperator.cs	(revision 15295)
@@ -0,0 +1,111 @@
+﻿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("-", "No reheats are performed.")]
+    [StorableClass]
+    public class NoReheatingOperator : 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";
+
+
+        #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]; }
+        }
+
+        #endregion
+
+        public NoReheatingOperator() : 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<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
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected NoReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected NoReheatingOperator(NoReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new NoReheatingOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+        }
+
+        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),
+                    base.Apply()
+                };
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/RandomWalkReheatingOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/RandomWalkReheatingOperator.cs	(revision 15295)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/RandomWalkReheatingOperator.cs	(revision 15295)
@@ -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: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs	(revision 15294)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs	(revision 15295)
@@ -1,5 +1,5 @@
 ﻿#region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21,5 +21,4 @@
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Analysis;
@@ -35,466 +34,597 @@
 using HeuristicLab.Random;
 
-namespace HeuristicLab.Algorithms.SimulatedAnnealing {
-  [Item("Simulated Annealing (SA)", "A simulated annealing algorithm.")]
-  [Creatable(CreatableAttribute.Categories.SingleSolutionAlgorithms, Priority = 140)]
-  [StorableClass]
-  public sealed class SimulatedAnnealing : HeuristicOptimizationEngineAlgorithm, IStorableContent {
-    public string Filename { get; set; }
-
-    #region Problem Properties
-    public override Type ProblemType {
-      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("Simulated Annealing", "An advanced simulated annealing algorithm.")]
+    [Creatable("Algorithms")]
+    [StorableClass]
+    public sealed class SimulatedAnnealing : HeuristicOptimizationEngineAlgorithm, IStorableContent
+    {
+        #region Strings
+        private const string SeedName = "Seed";
+        private const string SetSeedRandomlyName = "SetSeedRandomly";
+        private const string MoveGeneratorName = "MoveGenerator";
+        private const string MoveEvaluatorName = "MoveEvaluator";
+        private const string MoveMakerName = "MoveMaker";
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string ReheatingOperatorName = "ReheatingOperator";
+        private const string MaximumIterationsName = "MaximumIterations";
+        private const string InitialTemperatureName = "InitialTemperature";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string AnalyzerName = "Analyzer";
+        private const string RandomName = "Random";
+        private const string EvaluatedMovesName = "EvaluatedMoves";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string CoolingName = "Cooling";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string ResultsName = "Results";
+        private const string TemperatureChartName = "Temperature Chart";
+        private const string TemperatureAnalyzerName = "Temperature Analyzer";
+        private const string TemperatureInitializerName = "TemperatureInitializer";
+        #endregion
+
+        public string Filename { get; set; }
+
+        #region Problem Properties
+        public override Type ProblemType
+        {
+            get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
+        }
+        public new ISingleObjectiveHeuristicOptimizationProblem Problem
+        {
+            get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
+            set { base.Problem = value; }
+        }
+        #endregion
+
+        #region Parameter Properties
+        private ValueParameter<IntValue> SeedParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[SeedName]; }
+        }
+        private ValueParameter<BoolValue> SetSeedRandomlyParameter
+        {
+            get { return (ValueParameter<BoolValue>)Parameters[SetSeedRandomlyName]; }
+        }
+        public IConstrainedValueParameter<IMultiMoveGenerator> MoveGeneratorParameter
+        {
+            get { return (IConstrainedValueParameter<IMultiMoveGenerator>)Parameters[MoveGeneratorName]; }
+        }
+        public IConstrainedValueParameter<IMoveMaker> MoveMakerParameter
+        {
+            get { return (IConstrainedValueParameter<IMoveMaker>)Parameters[MoveMakerName]; }
+        }
+        public IConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter
+        {
+            get { return (IConstrainedValueParameter<ISingleObjectiveMoveEvaluator>)Parameters[MoveEvaluatorName]; }
+        }
+        public IConstrainedValueParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter
+        {
+            get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
+        }
+
+        public IConstrainedValueParameter<IReheatingOperator> ReheatingOperatorParameter
+        {
+            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> LowerTemperatureParameter
+        {
+            get { return (ValueParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        private ValueParameter<MultiAnalyzer> AnalyzerParameter
+        {
+            get { return (ValueParameter<MultiAnalyzer>)Parameters[AnalyzerName]; }
+        }
+        #endregion
+
+        #region Properties
+        public IntValue Seed
+        {
+            get { return SeedParameter.Value; }
+            set { SeedParameter.Value = value; }
+        }
+        public BoolValue SetSeedRandomly
+        {
+            get { return SetSeedRandomlyParameter.Value; }
+            set { SetSeedRandomlyParameter.Value = value; }
+        }
+        public IMultiMoveGenerator MoveGenerator
+        {
+            get { return MoveGeneratorParameter.Value; }
+            set { MoveGeneratorParameter.Value = value; }
+        }
+        public IMoveMaker MoveMaker
+        {
+            get { return MoveMakerParameter.Value; }
+            set { MoveMakerParameter.Value = value; }
+        }
+        public ISingleObjectiveMoveEvaluator MoveEvaluator
+        {
+            get { return MoveEvaluatorParameter.Value; }
+            set { MoveEvaluatorParameter.Value = value; }
+        }
+        public IDiscreteDoubleValueModifier AnnealingOperator
+        {
+            get { return AnnealingOperatorParameter.Value; }
+            set { AnnealingOperatorParameter.Value = value; }
+        }
+
+        public IReheatingOperator ReheatingOperator
+        {
+            get { return ReheatingOperatorParameter.Value; }
+            set { ReheatingOperatorParameter.Value = value; }
+        }
+        public ITemperatureInitializer TemperatureInitializer
+        {
+            get { return TemperatureInitializerParameter.Value; }
+            set { TemperatureInitializerParameter.Value = value; }
+        }
+
+        public IntValue MaximumIterations
+        {
+            get { return MaximumIterationsParameter.Value; }
+            set { MaximumIterationsParameter.Value = value; }
+        }
+        public DoubleValue LowerTemperature
+        {
+            get { return LowerTemperatureParameter.Value; }
+            set { LowerTemperatureParameter.Value = value; }
+        }
+        public MultiAnalyzer Analyzer
+        {
+            get { return AnalyzerParameter.Value; }
+            set { AnalyzerParameter.Value = value; }
+        }
+        private RandomCreator RandomCreator
+        {
+            get { return (RandomCreator)OperatorGraph.InitialOperator; }
+        }
+        private SolutionsCreator SolutionsCreator
+        {
+            get { return (SolutionsCreator)RandomCreator.Successor; }
+        }
+        private SimulatedAnnealingMainLoop MainLoop
+        {
+            get { return OperatorGraph.Iterate().OfType<SimulatedAnnealingMainLoop>().First(); }
+        }
+        #endregion
+
+        [StorableConstructor]
+        private SimulatedAnnealing(bool deserializing) : base(deserializing) { }
+        private SimulatedAnnealing(SimulatedAnnealing original, Cloner cloner)
+          : base(original, cloner)
+        {
+            RegisterEventHandlers();
+        }
+        public SimulatedAnnealing()
+          : base()
+        {
+            Parameters.Add(new ValueParameter<IntValue>(SeedName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+            Parameters.Add(new ValueParameter<BoolValue>(SetSeedRandomlyName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+            Parameters.Add(new ConstrainedValueParameter<IMultiMoveGenerator>(MoveGeneratorName, "The operator used to generate moves to the neighborhood of the current solution."));
+            Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>(MoveEvaluatorName, "The operator used to evaluate a move."));
+            Parameters.Add(new ConstrainedValueParameter<IMoveMaker>(MoveMakerName, "The operator used to perform a move."));
+            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>(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()));
+
+            var randomCreator = new RandomCreator();
+            var solutionsCreator = new SolutionsCreator();
+            var variableCreator = new VariableCreator();
+            var startTemperatureAssigner = new Assigner();
+            var endTemperatureAssigner = new Assigner();
+            var temperatureAssigner = new Assigner();
+            var resultsCollector = new ResultsCollector();
+            var mainLoop = new SimulatedAnnealingMainLoop();
+            OperatorGraph.InitialOperator = randomCreator;
+
+            randomCreator.RandomParameter.ActualName = RandomName;
+            randomCreator.SeedParameter.ActualName = SeedParameter.Name;
+            randomCreator.SeedParameter.Value = null;
+            randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
+            randomCreator.SetSeedRandomlyParameter.Value = null;
+            randomCreator.Successor = solutionsCreator;
+
+            solutionsCreator.NumberOfSolutions = new IntValue(1);
+            solutionsCreator.Successor = variableCreator;
+
+            variableCreator.Name = "Initialize Variables";
+            variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(InitialTemperatureName, new DoubleValue(Double.PositiveInfinity)));
+            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(EvaluatedMovesName, new IntValue()));
+            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(IterationsName, new IntValue(0)));
+            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(TemperatureStartIndexName, new IntValue(0)));
+            variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>(CoolingName, new BoolValue(true)));
+
+            variableCreator.Successor = startTemperatureAssigner;
+
+            startTemperatureAssigner.Name = "Assign Start Temperature";
+            startTemperatureAssigner.LeftSideParameter.ActualName = StartTemperatureName;
+            startTemperatureAssigner.RightSideParameter.ActualName = InitialTemperatureName;
+            startTemperatureAssigner.Successor = endTemperatureAssigner; 
+
+            endTemperatureAssigner.Name = "Assign End Temperature";
+            endTemperatureAssigner.LeftSideParameter.ActualName = EndTemperatureName;
+            endTemperatureAssigner.RightSideParameter.ActualName = LowerTemperatureParameter.Name;
+            endTemperatureAssigner.Successor = temperatureAssigner; 
+
+            temperatureAssigner.Name = "Initialize Temperature";
+            temperatureAssigner.LeftSideParameter.ActualName = TemperatureName;
+            temperatureAssigner.RightSideParameter.ActualName = StartTemperatureName;
+            temperatureAssigner.Successor =  resultsCollector;
+
+            resultsCollector.CopyValue = new BoolValue(false);
+            resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(EvaluatedMovesName, null));
+            resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(IterationsName, null));
+            resultsCollector.ResultsParameter.ActualName = ResultsName;
+            resultsCollector.Successor = mainLoop;
+
+            mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
+            mainLoop.AnnealingOperatorParameter.ActualName = AnnealingOperatorParameter.Name;
+            mainLoop.CoolingParameter.ActualName = CoolingName;
+            mainLoop.EndTemperatureParameter.ActualName = EndTemperatureName;
+            mainLoop.EvaluatedMovesParameter.ActualName = EvaluatedMovesName;
+
+            mainLoop.IterationsParameter.ActualName = IterationsName;
+            mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
+            mainLoop.MoveEvaluatorParameter.ActualName = MoveEvaluatorParameter.Name;
+            mainLoop.MoveGeneratorParameter.ActualName = MoveGeneratorParameter.Name;
+            mainLoop.MoveMakerParameter.ActualName = MoveMakerParameter.Name;
+            mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+            mainLoop.ResultsParameter.ActualName = ResultsName;
+            mainLoop.StartTemperatureParameter.ActualName = StartTemperatureName;
+            mainLoop.TemperatureStartIndexParameter.ActualName = TemperatureStartIndexName;
+            mainLoop.TemperatureParameter.ActualName = TemperatureName;
+
+            foreach (var op in ApplicationManager.Manager.GetInstances<IReheatingOperator>().OrderBy(x => x.Name))
+            {
+               
+                ReheatingOperatorParameter.ValidValues.Add(op);
+            }
+
+            foreach (var op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
+            {
+                AnnealingOperatorParameter.ValidValues.Add(op);
+            }
+
+            foreach(var op in ApplicationManager.Manager.GetInstances<ITemperatureInitializer>().OrderBy(x => x.Name))
+            {
+                TemperatureInitializerParameter.ValidValues.Add(op);
+            }
+
+            UpdateAnalyzers();
+
+            Parameterize();
+
+            RegisterEventHandlers();
+        }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new SimulatedAnnealing(this, cloner);
+        }
+
+        [StorableHook(HookType.AfterDeserialization)]
+        private void AfterDeserialization()
+        {
+            RegisterEventHandlers();
+        }
+
+        private void RegisterEventHandlers()
+        {
+            if (Problem != null)
+            {
+                Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+                foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
+                {
+                    op.MoveQualityParameter.ActualNameChanged += MoveEvaluator_MoveQualityParameter_ActualNameChanged;
+                }
+            }
+            MoveGeneratorParameter.ValueChanged += MoveGeneratorParameter_ValueChanged;
+            MoveEvaluatorParameter.ValueChanged += MoveEvaluatorParameter_ValueChanged;
+        }
+
+        public override void Prepare()
+        {
+            if (Problem != null && MoveGenerator != null && MoveMaker != null && MoveEvaluator != null)
+                base.Prepare();
+        }
+
+        #region Events
+        protected override void OnProblemChanged()
+        {
+            foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
+            {
+                op.MoveQualityParameter.ActualNameChanged += MoveEvaluator_MoveQualityParameter_ActualNameChanged;
+            }
+            UpdateMoveGenerator();
+            UpdateMoveOperators();
+            UpdateAnalyzers();
+            Parameterize();
+            Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+            base.OnProblemChanged();
+        }
+        protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e)
+        {
+            Parameterize();
+            base.Problem_SolutionCreatorChanged(sender, e);
+        }
+        protected override void Problem_EvaluatorChanged(object sender, EventArgs e)
+        {
+            Parameterize();
+            Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+            base.Problem_EvaluatorChanged(sender, e);
+        }
+        protected override void Problem_OperatorsChanged(object sender, EventArgs e)
+        {
+            foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
+            {
+                op.MoveQualityParameter.ActualNameChanged -= MoveEvaluator_MoveQualityParameter_ActualNameChanged;
+                op.MoveQualityParameter.ActualNameChanged += MoveEvaluator_MoveQualityParameter_ActualNameChanged;
+            }
+            UpdateMoveGenerator();
+            UpdateMoveOperators();
+            UpdateAnalyzers();
+            Parameterize();
+            base.Problem_OperatorsChanged(sender, e);
+        }
+        private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e)
+        {
+            Parameterize();
+        }
+        private void MoveGeneratorParameter_ValueChanged(object sender, EventArgs e)
+        {
+            UpdateMoveOperators();
+        }
+        private void MoveEvaluatorParameter_ValueChanged(object sender, EventArgs e)
+        {
+            Parameterize();
+        }
+        private void MoveEvaluator_MoveQualityParameter_ActualNameChanged(object sender, EventArgs e)
+        {
+            if (sender == MoveEvaluator) Parameterize();
+        }
+        #endregion
+
+        #region Helpers
+
+        private void UpdateMoveGenerator()
+        {
+            var oldMoveGenerator = MoveGenerator;
+            var defaultMoveGenerator = Problem.Operators.OfType<IMultiMoveGenerator>().FirstOrDefault();
+
+            MoveGeneratorParameter.ValidValues.Clear();
+
+            if (Problem != null)
+            {
+                foreach (var generator in Problem.Operators.OfType<IMultiMoveGenerator>().OrderBy(x => x.Name))
+                    MoveGeneratorParameter.ValidValues.Add(generator);
+            }
+
+            if (oldMoveGenerator != null)
+            {
+                var newMoveGenerator = MoveGeneratorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveGenerator.GetType());
+                if (newMoveGenerator != null) MoveGenerator = newMoveGenerator;
+                else oldMoveGenerator = null;
+            }
+            if (oldMoveGenerator == null && defaultMoveGenerator != null)
+                MoveGenerator = defaultMoveGenerator;
+
+            UpdateMoveOperators();
+        }
+
+        private void UpdateMoveOperators()
+        {
+            var oldMoveMaker = MoveMaker;
+            var oldMoveEvaluator = MoveEvaluator;
+
+            MoveMakerParameter.ValidValues.Clear();
+            MoveEvaluatorParameter.ValidValues.Clear();
+
+            if (MoveGenerator != null)
+            {
+                var moveTypes = MoveGenerator.GetType().GetInterfaces().Where(x => typeof(IMoveOperator).IsAssignableFrom(x)).ToList();
+                foreach (var type in moveTypes.ToList())
+                {
+                    if (moveTypes.Any(t => t != type && type.IsAssignableFrom(t)))
+                        moveTypes.Remove(type);
+                }
+                var operators = Problem.Operators.Where(op => moveTypes.Any(m => m.IsInstanceOfType(op))).ToList();
+                var defaultMoveMaker = operators.OfType<IMoveMaker>().FirstOrDefault();
+                var defaultMoveEvaluator = operators.OfType<ISingleObjectiveMoveEvaluator>().FirstOrDefault();
+
+                foreach (var moveMaker in operators.OfType<IMoveMaker>().OrderBy(op => op.Name))
+                    MoveMakerParameter.ValidValues.Add(moveMaker);
+
+                foreach (var moveEvaluator in operators.OfType<ISingleObjectiveMoveEvaluator>().OrderBy(op => op.Name))
+                    MoveEvaluatorParameter.ValidValues.Add(moveEvaluator);
+
+                if (oldMoveMaker != null)
+                {
+                    var mm = MoveMakerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveMaker.GetType());
+                    if (mm != null) MoveMaker = mm;
+                    else oldMoveMaker = null;
+                }
+                if (oldMoveMaker == null && defaultMoveMaker != null)
+                    MoveMaker = defaultMoveMaker;
+
+                if (oldMoveEvaluator != null)
+                {
+                    var me = MoveEvaluatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveEvaluator.GetType());
+                    if (me != null) MoveEvaluator = me;
+                    else oldMoveEvaluator = null;
+                }
+                if (oldMoveEvaluator == null & defaultMoveEvaluator != null)
+                    MoveEvaluator = defaultMoveEvaluator;
+            }
+        }
+
+        private void UpdateAnalyzers()
+        {
+            Analyzer.Operators.Clear();
+            if (Problem != null)
+            {
+                foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>())
+                {
+                    foreach (var param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
+                        param.Depth = 0;
+                    Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+                }
+            }
+            var qualityAnalyzer = new QualityAnalyzer();
+            var temperatureAnalyzer = new SingleValueAnalyzer { Name = TemperatureAnalyzerName };
+            Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+            Analyzer.Operators.Add(temperatureAnalyzer, temperatureAnalyzer.EnabledByDefault);
+        }
+
+        private void Parameterize()
+        {
+
+            #region IStochasticOperator
+            if (Problem != null)
+            {
+                foreach (var op in Problem.Operators.OfType<IStochasticOperator>())
+                {
+                    op.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+                    op.RandomParameter.Hidden = true;
+                }
+            }
+            #endregion
+
+            #region IIterationBasedOperator
+            if (Problem != null)
+            {
+                foreach (var op in Problem.Operators.OfType<IIterationBasedOperator>())
+                {
+                    op.IterationsParameter.ActualName = IterationsName;
+                    op.IterationsParameter.Hidden = true;
+                    op.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
+                    op.MaximumIterationsParameter.Hidden = true;
+                }
+            }
+            #endregion
+
+            #region Analyzers
+
+            foreach (var qualityAnalyzer in Analyzer.Operators.OfType<QualityAnalyzer>())
+            {
+                qualityAnalyzer.ResultsParameter.ActualName = ResultsName;
+                if (Problem != null)
+                {
+                    qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+                    qualityAnalyzer.MaximizationParameter.Hidden = true;
+                    qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+                    qualityAnalyzer.QualityParameter.Depth = 0;
+                    qualityAnalyzer.QualityParameter.Hidden = true;
+                    qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+                    qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
+                }
+                else
+                {
+                    qualityAnalyzer.MaximizationParameter.Hidden = false;
+                    qualityAnalyzer.QualityParameter.Hidden = false;
+                    qualityAnalyzer.BestKnownQualityParameter.Hidden = false;
+                }
+            }
+
+            var temperatureAnalyzer = Analyzer.Operators.OfType<SingleValueAnalyzer>().FirstOrDefault(x => x.Name == TemperatureAnalyzerName);
+            if (temperatureAnalyzer != null)
+            {
+                temperatureAnalyzer.ResultsParameter.ActualName = ResultsName;
+                temperatureAnalyzer.ResultsParameter.Hidden = true;
+                temperatureAnalyzer.ValueParameter.ActualName = TemperatureName;
+                temperatureAnalyzer.ValueParameter.Hidden = true;
+                temperatureAnalyzer.ValuesParameter.ActualName = TemperatureChartName;
+                temperatureAnalyzer.ValuesParameter.Hidden = true;
+            }
+
+            #endregion
+
+            #region SolutionCreator
+            if (Problem != null)
+            {
+                SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+                SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+            }
+            #endregion
+
+            #region Annealing/Reheating Operators
+            foreach (var op in AnnealingOperatorParameter.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.ActualName = LowerTemperatureParameter.Name;
+                op.EndValueParameter.Hidden = true;
+            }
+            foreach (var op in ReheatingOperatorParameter.ValidValues)
+            {
+                op.Parameterize();
+            }
+            #endregion
+
+            #region Move Operators
+            if (Problem != null)
+            {
+                foreach (var op in Problem.Operators.OfType<IMultiMoveGenerator>())
+                {
+                    op.SampleSizeParameter.Value = new IntValue(1);
+                    op.SampleSizeParameter.Hidden = true;
+                }
+                foreach (var op in Problem.Operators.OfType<IMoveMaker>())
+                {
+                    op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+                    op.QualityParameter.Hidden = true;
+                    if (MoveEvaluator != null)
+                    {
+                        op.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
+                        op.MoveQualityParameter.Hidden = true;
+                    }
+                    else
+                    {
+                        op.MoveQualityParameter.Hidden = false;
+                    }
+                }
+                foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
+                {
+                    op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+                    op.QualityParameter.Hidden = true;
+                }
+            }
+            #endregion
+
+            #region MainLoop
+            if (Problem != null)
+            {
+                MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+                MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+                MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+                if (MoveEvaluator != null)
+                    MainLoop.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
+            }
+            #endregion
+
+        }
+        #endregion
     }
-    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
-      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
-      set { base.Problem = value; }
-    }
-    #endregion
-
-    #region Parameter Properties
-    private ValueParameter<IntValue> SeedParameter {
-      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
-    }
-    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
-      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
-    }
-    public IConstrainedValueParameter<IMultiMoveGenerator> MoveGeneratorParameter {
-      get { return (IConstrainedValueParameter<IMultiMoveGenerator>)Parameters["MoveGenerator"]; }
-    }
-    public IConstrainedValueParameter<IMoveMaker> MoveMakerParameter {
-      get { return (IConstrainedValueParameter<IMoveMaker>)Parameters["MoveMaker"]; }
-    }
-    public IConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter {
-      get { return (IConstrainedValueParameter<ISingleObjectiveMoveEvaluator>)Parameters["MoveEvaluator"]; }
-    }
-    public IConstrainedValueParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter {
-      get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["AnnealingOperator"]; }
-    }
-    private ValueParameter<IntValue> MaximumIterationsParameter {
-      get { return (ValueParameter<IntValue>)Parameters["MaximumIterations"]; }
-    }
-    private ValueParameter<IntValue> InnerIterationsParameter {
-      get { return (ValueParameter<IntValue>)Parameters["InnerIterations"]; }
-    }
-    private ValueParameter<DoubleValue> StartTemperatureParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["StartTemperature"]; }
-    }
-    private ValueParameter<DoubleValue> EndTemperatureParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["EndTemperature"]; }
-    }
-    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
-      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
-    }
-    #endregion
-
-    #region Properties
-    public IntValue Seed {
-      get { return SeedParameter.Value; }
-      set { SeedParameter.Value = value; }
-    }
-    public BoolValue SetSeedRandomly {
-      get { return SetSeedRandomlyParameter.Value; }
-      set { SetSeedRandomlyParameter.Value = value; }
-    }
-    public IMultiMoveGenerator MoveGenerator {
-      get { return MoveGeneratorParameter.Value; }
-      set { MoveGeneratorParameter.Value = value; }
-    }
-    public IMoveMaker MoveMaker {
-      get { return MoveMakerParameter.Value; }
-      set { MoveMakerParameter.Value = value; }
-    }
-    public ISingleObjectiveMoveEvaluator MoveEvaluator {
-      get { return MoveEvaluatorParameter.Value; }
-      set { MoveEvaluatorParameter.Value = value; }
-    }
-    public IDiscreteDoubleValueModifier AnnealingOperator {
-      get { return AnnealingOperatorParameter.Value; }
-      set { AnnealingOperatorParameter.Value = value; }
-    }
-    public IntValue MaximumIterations {
-      get { return MaximumIterationsParameter.Value; }
-      set { MaximumIterationsParameter.Value = value; }
-    }
-    public IntValue InnerIterations {
-      get { return InnerIterationsParameter.Value; }
-      set { InnerIterationsParameter.Value = value; }
-    }
-    public DoubleValue StartTemperature {
-      get { return StartTemperatureParameter.Value; }
-      set { StartTemperatureParameter.Value = value; }
-    }
-    public DoubleValue EndTemperature {
-      get { return EndTemperatureParameter.Value; }
-      set { EndTemperatureParameter.Value = value; }
-    }
-    public MultiAnalyzer Analyzer {
-      get { return AnalyzerParameter.Value; }
-      set { AnalyzerParameter.Value = value; }
-    }
-    private RandomCreator RandomCreator {
-      get { return (RandomCreator)OperatorGraph.InitialOperator; }
-    }
-    private SolutionsCreator SolutionsCreator {
-      get { return (SolutionsCreator)RandomCreator.Successor; }
-    }
-    private SimulatedAnnealingMainLoop MainLoop {
-      get { return FindMainLoop(SolutionsCreator.Successor); }
-    }
-    [Storable]
-    private QualityAnalyzer qualityAnalyzer;
-    [Storable]
-    private SingleValueAnalyzer temperatureAnalyzer;
-    #endregion
-
-    [StorableConstructor]
-    private SimulatedAnnealing(bool deserializing) : base(deserializing) { }
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (temperatureAnalyzer == null) {
-        temperatureAnalyzer = new SingleValueAnalyzer();
-        temperatureAnalyzer.Name = "TemperatureAnalyzer";
-        temperatureAnalyzer.ResultsParameter.ActualName = "Results";
-        temperatureAnalyzer.ValueParameter.ActualName = "Temperature";
-        temperatureAnalyzer.ValuesParameter.ActualName = "Temperature Chart";
-        Analyzer.Operators.Add(temperatureAnalyzer);
-      }
-      Initialize();
-    }
-    private SimulatedAnnealing(SimulatedAnnealing original, Cloner cloner)
-      : base(original, cloner) {
-      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
-      temperatureAnalyzer = cloner.Clone(original.temperatureAnalyzer);
-      Initialize();
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SimulatedAnnealing(this, cloner);
-    }
-    public SimulatedAnnealing()
-      : base() {
-      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
-      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
-      Parameters.Add(new ConstrainedValueParameter<IMultiMoveGenerator>("MoveGenerator", "The operator used to generate moves to the neighborhood of the current solution."));
-      Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>("MoveEvaluator", "The operator used to evaluate a move."));
-      Parameters.Add(new ConstrainedValueParameter<IMoveMaker>("MoveMaker", "The operator used to perform a move."));
-      Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>("AnnealingOperator", "The operator used to modify the temperature."));
-      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(100)));
-      Parameters.Add(new ValueParameter<IntValue>("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again).", new IntValue(10)));
-      Parameters.Add(new ValueParameter<DoubleValue>("StartTemperature", "The initial temperature.", new DoubleValue(100)));
-      Parameters.Add(new ValueParameter<DoubleValue>("EndTemperature", "The final temperature which should be reached when iterations reaches maximum iterations.", new DoubleValue(1e-6)));
-      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
-
-      RandomCreator randomCreator = new RandomCreator();
-      SolutionsCreator solutionsCreator = new SolutionsCreator();
-      VariableCreator variableCreator = new VariableCreator();
-      ResultsCollector resultsCollector = new ResultsCollector();
-      SimulatedAnnealingMainLoop mainLoop = new SimulatedAnnealingMainLoop();
-      OperatorGraph.InitialOperator = randomCreator;
-
-      randomCreator.RandomParameter.ActualName = "Random";
-      randomCreator.SeedParameter.ActualName = SeedParameter.Name;
-      randomCreator.SeedParameter.Value = null;
-      randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
-      randomCreator.SetSeedRandomlyParameter.Value = null;
-      randomCreator.Successor = solutionsCreator;
-
-      solutionsCreator.NumberOfSolutions = new IntValue(1);
-      solutionsCreator.Successor = variableCreator;
-
-      variableCreator.Name = "Initialize EvaluatedMoves";
-      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedMoves", new IntValue()));
-      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
-      variableCreator.Successor = resultsCollector;
-
-      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Moves", null, "EvaluatedMoves"));
-      resultsCollector.ResultsParameter.ActualName = "Results";
-      resultsCollector.Successor = mainLoop;
-
-      mainLoop.MoveGeneratorParameter.ActualName = MoveGeneratorParameter.Name;
-      mainLoop.MoveEvaluatorParameter.ActualName = MoveEvaluatorParameter.Name;
-      mainLoop.MoveMakerParameter.ActualName = MoveMakerParameter.Name;
-      mainLoop.AnnealingOperatorParameter.ActualName = AnnealingOperatorParameter.Name;
-      mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
-      mainLoop.TemperatureParameter.ActualName = "Temperature";
-      mainLoop.StartTemperatureParameter.ActualName = StartTemperatureParameter.Name;
-      mainLoop.EndTemperatureParameter.ActualName = EndTemperatureParameter.Name;
-      mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
-      mainLoop.ResultsParameter.ActualName = "Results";
-      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
-      mainLoop.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
-      mainLoop.IterationsParameter.ActualName = "Iterations";
-
-      foreach (IDiscreteDoubleValueModifier op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
-        AnnealingOperatorParameter.ValidValues.Add(op);
-      ParameterizeAnnealingOperators();
-
-      qualityAnalyzer = new QualityAnalyzer();
-      temperatureAnalyzer = new SingleValueAnalyzer();
-      temperatureAnalyzer.Name = "TemperatureAnalyzer";
-      ParameterizeAnalyzers();
-      UpdateAnalyzers();
-
-      Initialize();
-    }
-
-    public override void Prepare() {
-      if (Problem != null && MoveGenerator != null && MoveMaker != null && MoveEvaluator != null)
-        base.Prepare();
-    }
-
-    #region Events
-    protected override void OnProblemChanged() {
-      ParameterizeStochasticOperator(Problem.SolutionCreator);
-      ParameterizeStochasticOperator(Problem.Evaluator);
-      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
-      foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>()) {
-        op.MoveQualityParameter.ActualNameChanged += new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
-      }
-      ParameterizeSolutionsCreator();
-      ParameterizeMainLoop();
-      UpdateMoveGenerator();
-      UpdateMoveParameters();
-      UpdateAnalyzers();
-      ParameterizeMoveEvaluators();
-      ParameterizeMoveMakers();
-      ParameterizeMoveGenerators();
-      ParameterizeAnalyzers();
-      ParameterizeIterationBasedOperators();
-      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      base.OnProblemChanged();
-    }
-    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
-      ParameterizeStochasticOperator(Problem.SolutionCreator);
-      ParameterizeSolutionsCreator();
-      base.Problem_SolutionCreatorChanged(sender, e);
-    }
-    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
-      ParameterizeStochasticOperator(Problem.Evaluator);
-      ParameterizeSolutionsCreator();
-      ParameterizeMainLoop();
-      ParameterizeMoveEvaluators();
-      ParameterizeMoveMakers();
-      ParameterizeAnalyzers();
-      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      base.Problem_EvaluatorChanged(sender, e);
-    }
-    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
-      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
-      // This may seem pointless, but some operators already have the eventhandler registered, others don't
-      // FIXME: Is there another way to solve this problem?
-      foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>()) {
-        op.MoveQualityParameter.ActualNameChanged -= new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
-        op.MoveQualityParameter.ActualNameChanged += new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
-      }
-      UpdateMoveGenerator();
-      UpdateMoveParameters();
-      UpdateAnalyzers();
-      ParameterizeMainLoop();
-      ParameterizeMoveEvaluators();
-      ParameterizeMoveMakers();
-      ParameterizeMoveGenerators();
-      ParameterizeIterationBasedOperators();
-      base.Problem_OperatorsChanged(sender, e);
-    }
-    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeMainLoop();
-      ParameterizeMoveEvaluators();
-      ParameterizeMoveMakers();
-      ParameterizeAnalyzers();
-    }
-    private void MoveGeneratorParameter_ValueChanged(object sender, EventArgs e) {
-      UpdateMoveParameters();
-    }
-    private void MoveEvaluatorParameter_ValueChanged(object sender, EventArgs e) {
-      ParameterizeMainLoop();
-      ParameterizeMoveEvaluators();
-      ParameterizeMoveMakers();
-    }
-    private void MoveEvaluator_MoveQualityParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeMainLoop();
-      ParameterizeMoveEvaluators();
-      ParameterizeMoveMakers();
-    }
-    #endregion
-
-    #region Helpers
-    private void Initialize() {
-      if (Problem != null) {
-        Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-        foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>()) {
-          op.MoveQualityParameter.ActualNameChanged += new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
-        }
-      }
-      MoveGeneratorParameter.ValueChanged += new EventHandler(MoveGeneratorParameter_ValueChanged);
-      MoveEvaluatorParameter.ValueChanged += new EventHandler(MoveEvaluatorParameter_ValueChanged);
-    }
-    private void UpdateMoveGenerator() {
-      IMultiMoveGenerator oldMoveGenerator = MoveGenerator;
-      IMultiMoveGenerator defaultMoveGenerator = Problem.Operators.OfType<IMultiMoveGenerator>().FirstOrDefault();
-      MoveGeneratorParameter.ValidValues.Clear();
-      if (Problem != null) {
-        foreach (IMultiMoveGenerator generator in Problem.Operators.OfType<IMultiMoveGenerator>().OrderBy(x => x.Name))
-          MoveGeneratorParameter.ValidValues.Add(generator);
-      }
-      if (oldMoveGenerator != null) {
-        IMultiMoveGenerator newMoveGenerator = MoveGeneratorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveGenerator.GetType());
-        if (newMoveGenerator != null) MoveGenerator = newMoveGenerator;
-        else oldMoveGenerator = null;
-      }
-      if (oldMoveGenerator == null && defaultMoveGenerator != null)
-        MoveGenerator = defaultMoveGenerator;
-      if (MoveGenerator == null) {
-        ClearMoveParameters();
-      }
-    }
-    private void ParameterizeAnalyzers() {
-      qualityAnalyzer.ResultsParameter.ActualName = "Results";
-      if (Problem != null) {
-        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
-        qualityAnalyzer.MaximizationParameter.Hidden = true;
-        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
-        qualityAnalyzer.QualityParameter.Depth = 0;
-        qualityAnalyzer.QualityParameter.Hidden = true;
-        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
-        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
-      } else {
-        qualityAnalyzer.MaximizationParameter.Hidden = false;
-        qualityAnalyzer.QualityParameter.Hidden = false;
-        qualityAnalyzer.BestKnownQualityParameter.Hidden = false;
-        temperatureAnalyzer.ResultsParameter.ActualName = "Results";
-        temperatureAnalyzer.ValueParameter.ActualName = "Temperature";
-        temperatureAnalyzer.ValuesParameter.ActualName = "Temperature Chart";
-      }
-    }
-    private void UpdateMoveParameters() {
-      IMoveMaker oldMoveMaker = MoveMaker;
-      ISingleObjectiveMoveEvaluator oldMoveEvaluator = MoveEvaluator;
-      ClearMoveParameters();
-
-      if (MoveGenerator != null) {
-        List<Type> moveTypes = MoveGenerator.GetType().GetInterfaces().Where(x => typeof(IMoveOperator).IsAssignableFrom(x)).ToList();
-        foreach (Type type in moveTypes.ToList()) {
-          if (moveTypes.Any(t => t != type && type.IsAssignableFrom(t)))
-            moveTypes.Remove(type);
-        }
-        var operators = Problem.Operators.Where(op => moveTypes.Any(m => m.IsInstanceOfType(op))).ToList();
-        IMoveMaker defaultMoveMaker = operators.OfType<IMoveMaker>().FirstOrDefault();
-        ISingleObjectiveMoveEvaluator defaultMoveEvaluator = operators.OfType<ISingleObjectiveMoveEvaluator>().FirstOrDefault();
-
-        foreach (IMoveMaker moveMaker in operators.OfType<IMoveMaker>().OrderBy(op => op.Name))
-          MoveMakerParameter.ValidValues.Add(moveMaker);
-        foreach (ISingleObjectiveMoveEvaluator moveEvaluator in operators.OfType<ISingleObjectiveMoveEvaluator>().OrderBy(op => op.Name))
-          MoveEvaluatorParameter.ValidValues.Add(moveEvaluator);
-
-        if (oldMoveMaker != null) {
-          IMoveMaker mm = MoveMakerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveMaker.GetType());
-          if (mm != null) MoveMaker = mm;
-          else oldMoveMaker = null;
-        }
-        if (oldMoveMaker == null && defaultMoveMaker != null)
-          MoveMaker = defaultMoveMaker;
-
-        if (oldMoveEvaluator != null) {
-          ISingleObjectiveMoveEvaluator me = MoveEvaluatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveEvaluator.GetType());
-          if (me != null) MoveEvaluator = me;
-          else oldMoveEvaluator = null;
-        }
-        if (oldMoveEvaluator == null & defaultMoveEvaluator != null)
-          MoveEvaluator = defaultMoveEvaluator;
-      }
-    }
-    private void ClearMoveParameters() {
-      MoveMakerParameter.ValidValues.Clear();
-      MoveEvaluatorParameter.ValidValues.Clear();
-    }
-    private void ParameterizeSolutionsCreator() {
-      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
-      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
-    }
-    private void ParameterizeMainLoop() {
-      if (Problem != null) {
-        MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
-        MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
-        MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
-      }
-      if (MoveEvaluator != null)
-        MainLoop.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
-    }
-    private void ParameterizeStochasticOperator(IOperator op) {
-      if (op is IStochasticOperator) {
-        IStochasticOperator stOp = (IStochasticOperator)op;
-        stOp.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
-        stOp.RandomParameter.Hidden = true;
-      }
-    }
-    private void ParameterizeMoveEvaluators() {
-      foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>()) {
-        op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
-        op.QualityParameter.Hidden = true;
-      }
-    }
-    private void ParameterizeMoveMakers() {
-      foreach (IMoveMaker op in Problem.Operators.OfType<IMoveMaker>()) {
-        op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
-        op.QualityParameter.Hidden = true;
-        if (MoveEvaluator != null) {
-          op.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
-          op.MoveQualityParameter.Hidden = true;
-        } else {
-          op.MoveQualityParameter.Hidden = false;
-        }
-      }
-    }
-    private void ParameterizeAnnealingOperators() {
-      foreach (IDiscreteDoubleValueModifier op in AnnealingOperatorParameter.ValidValues) {
-        op.IndexParameter.ActualName = "Iterations";
-        op.IndexParameter.Hidden = true;
-        op.StartIndexParameter.Value = new IntValue(0);
-        op.EndIndexParameter.ActualName = MaximumIterationsParameter.Name;
-        op.ValueParameter.ActualName = "Temperature";
-        op.ValueParameter.Hidden = true;
-        op.StartValueParameter.ActualName = StartTemperatureParameter.Name;
-        op.StartValueParameter.Hidden = true;
-        op.EndValueParameter.ActualName = EndTemperatureParameter.Name;
-        op.EndValueParameter.Hidden = true;
-        ParameterizeStochasticOperator(op);
-      }
-    }
-    private void ParameterizeMoveGenerators() {
-      foreach (IMultiMoveGenerator op in Problem.Operators.OfType<IMultiMoveGenerator>()) {
-        op.SampleSizeParameter.ActualName = InnerIterationsParameter.Name;
-        op.SampleSizeParameter.Hidden = true;
-      }
-    }
-    private void ParameterizeIterationBasedOperators() {
-      if (Problem != null) {
-        foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
-          op.IterationsParameter.ActualName = "Iterations";
-          op.IterationsParameter.Hidden = true;
-          op.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
-          op.MaximumIterationsParameter.Hidden = true;
-        }
-      }
-    }
-    private void UpdateAnalyzers() {
-      Analyzer.Operators.Clear();
-      if (Problem != null) {
-        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
-          foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
-            param.Depth = 0;
-          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
-        }
-      }
-      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
-      Analyzer.Operators.Add(temperatureAnalyzer, temperatureAnalyzer.EnabledByDefault);
-    }
-    private SimulatedAnnealingMainLoop FindMainLoop(IOperator start) {
-      IOperator mainLoop = start;
-      while (mainLoop != null && !(mainLoop is SimulatedAnnealingMainLoop))
-        mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
-      if (mainLoop == null) return null;
-      else return (SimulatedAnnealingMainLoop)mainLoop;
-    }
-    #endregion
-  }
 }
Index: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs	(revision 15294)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs	(revision 15295)
@@ -377,5 +377,5 @@
       VariableCreator variableCreator = new VariableCreator();
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(loop.IterationsParameter.ActualName, new IntValue(0)));
-
+        
       variableCreator.Successor = loop;
 
Index: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs	(revision 15294)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs	(revision 15295)
@@ -1,5 +1,5 @@
 ﻿#region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -28,227 +28,308 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Algorithms.SimulatedAnnealing {
-  /// <summary>
-  /// An operator which represents a simulated annealing.
-  /// </summary>
-  [Item("SimulatedAnnealingMainLoop", "An operator which represents the main loop of a simulated annealing algorithm.")]
-  [StorableClass]
-  public sealed class SimulatedAnnealingMainLoop : AlgorithmOperator {
-    #region Parameter properties
-    public ValueLookupParameter<IRandom> RandomParameter {
-      get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("SimulatedAnnealingMainLoop", "An operator which represents the main loop of a simulated annealing algorithm.")]
+    [StorableClass]
+    public sealed class SimulatedAnnealingMainLoop : AlgorithmOperator
+    {
+        #region Strings
+        private const string MoveGeneratorName = "MoveGenerator";
+        private const string MoveEvaluatorName = "MoveEvaluator";
+        private const string MoveMakerName = "MoveMaker";
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string ReheatingOperatorName = "ReheatingOperator";
+        private const string MaximumIterationsName = "MaximumIterations";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string AnalyzerName = "Analyzer";
+        private const string RandomName = "Random";
+        private const string EvaluatedMovesName = "EvaluatedMoves";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string CoolingName = "Cooling";
+        private const string InitialTemperatureName = "InitialTemperature";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string ResultsName = "Results";
+        private const string MaximizationName = "Maximization";
+        private const string QualityName = "Quality";
+        private const string BestKnownQualityName = "BestKnownQuality";
+        private const string MoveQualityName = "MoveQuality";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string TerminateName = "Terminate";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string ConsecutiveRejectedSolutionsCountName = "ConsecutiveRejectedSolutions";
+        private const string AverageAcceptanceRatioName = "AverageAcceptanceRatio";
+        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
+
+        #region Parameter properties
+        public IValueLookupParameter<IRandom> RandomParameter
+        {
+            get { return (IValueLookupParameter<IRandom>)Parameters[RandomName]; }
+        }
+        public IValueLookupParameter<BoolValue> MaximizationParameter
+        {
+            get { return (IValueLookupParameter<BoolValue>)Parameters[MaximizationName]; }
+        }
+        public ILookupParameter<DoubleValue> QualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[QualityName]; }
+        }
+        public IValueLookupParameter<DoubleValue> BestKnownQualityParameter
+        {
+            get { return (IValueLookupParameter<DoubleValue>)Parameters[BestKnownQualityName]; }
+        }
+        public IValueLookupParameter<DoubleValue> LastQualityParameter
+        {
+            get { return (IValueLookupParameter<DoubleValue>)Parameters[LastQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> InitialTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[InitialTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> MoveQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public IValueLookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public IValueLookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (IValueLookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        public IValueLookupParameter<IOperator> MoveGeneratorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[MoveGeneratorName]; }
+        }
+        public IValueLookupParameter<IOperator> MoveEvaluatorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[MoveEvaluatorName]; }
+        }
+        public IValueLookupParameter<IOperator> MoveMakerParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[MoveMakerName]; }
+        }
+        public IValueLookupParameter<IOperator> AnnealingOperatorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        }
+        public IValueLookupParameter<IOperator> ReheatingOperatorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[ReheatingOperatorName]; }
+        }
+        public IValueLookupParameter<IOperator> AnalyzerParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[AnalyzerName]; }
+        }
+        public IValueLookupParameter<VariableCollection> ResultsParameter
+        {
+            get { return (IValueLookupParameter<VariableCollection>)Parameters[ResultsName]; }
+        }
+        public ILookupParameter<IntValue> EvaluatedMovesParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[EvaluatedMovesName]; }
+        }
+        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]; }
+        }
+        #endregion
+
+        [StorableConstructor]
+        private SimulatedAnnealingMainLoop(bool deserializing) : base(deserializing) { }
+        private SimulatedAnnealingMainLoop(SimulatedAnnealingMainLoop original, Cloner cloner)
+          : base(original, cloner)
+        {
+        }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new SimulatedAnnealingMainLoop(this, cloner);
+        }
+        public SimulatedAnnealingMainLoop()
+          : base()
+        {
+            Initialize();
+        }
+
+        private void Initialize()
+        {
+            #region Create parameters
+            Parameters.Add(new ValueLookupParameter<IRandom>(RandomName, "A pseudo random number generator."));
+            Parameters.Add(new ValueLookupParameter<BoolValue>(MaximizationName, "True if the problem is a maximization problem, otherwise false."));
+            Parameters.Add(new LookupParameter<DoubleValue>(QualityName, "The value which represents the quality of a solution."));
+            Parameters.Add(new ValueLookupParameter<DoubleValue>(BestKnownQualityName, "The best known quality value found so far."));
+            Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
+
+            Parameters.Add(new ValueLookupParameter<IOperator>(MoveGeneratorName, "The operator that generates the moves."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(MoveEvaluatorName, "The operator that evaluates a move."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(MoveMakerName, "The operator that performs a move and updates the quality."));
+            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."));
+            Parameters.Add(new ValueLookupParameter<VariableCollection>(ResultsName, "The variable collection where results should be stored."));
+            Parameters.Add(new LookupParameter<IntValue>(EvaluatedMovesName, "The number of evaluated moves."));
+
+            Parameters.Add(new LookupParameter<DoubleValue>(InitialTemperatureName, "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
+
+            #region Create operators
+            var variableCreator = new VariableCreator();
+            var ssp1 = new SubScopesProcessor();
+            var analyzer1 = new Placeholder();
+            var ssp2 = new SubScopesProcessor();
+            var resultsCollector = new ResultsCollector();
+            var mainProcessor = new SubScopesProcessor();
+            var moveGenerator = new Placeholder();
+            var moveEvaluationProcessor = new SubScopesProcessor();
+            var moveEvaluator = new Placeholder();
+            var evaluatedMovesCounter = new IntCounter();
+            var qualityComparator = new ProbabilisticQualityComparator();
+            var acceptsQualityBranch = new ConditionalBranch();
+            var moveMaker = new Placeholder();
+            var temperatureController = new TemperatureController();
+            var subScopesRemover = new SubScopesRemover();
+            var iterationsCounter = new IntCounter();
+            var iterationsComparator = new Comparator();
+            var ssp3 = new SubScopesProcessor();
+            var analyzer2 = new Placeholder();
+            var iterationsTermination = new ConditionalBranch();
+
+            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)));
+            variableCreator.CollectedValues.Add(new ValueParameter<ItemList<BoolValue>>(AcceptanceMemoryName, new ItemList<BoolValue>()));
+            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";
+            analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+            moveGenerator.Name = "Move generator";
+            moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
+
+            moveEvaluator.Name = "Move evaluator";
+            moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
+
+            evaluatedMovesCounter.Name = "EvaluatedMoves++";
+            evaluatedMovesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
+            evaluatedMovesCounter.Increment = new IntValue(1);
+
+            qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
+            qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
+            qualityComparator.ResultParameter.ActualName = IsAcceptedName;
+            qualityComparator.DampeningParameter.ActualName = TemperatureParameter.Name;
+
+            acceptsQualityBranch.ConditionParameter.ActualName = IsAcceptedName;
+
+            moveMaker.Name = "Move maker";
+            moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
+
+           
+            subScopesRemover.RemoveAllSubScopes = true;
+
+            iterationsCounter.Name = "Iterations++";
+            iterationsCounter.Increment = new IntValue(1);
+            iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
+
+            iterationsComparator.Name = "Iterations >= MaximumIterations";
+            iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
+            iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
+            iterationsComparator.ResultParameter.ActualName = TerminateName;
+            iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
+
+            analyzer2.Name = "Analyzer (placeholder)";
+            analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+            iterationsTermination.Name = "Iterations termination condition";
+            iterationsTermination.ConditionParameter.ActualName = TerminateName;
+            #endregion
+
+            #region Create operator graph
+            OperatorGraph.InitialOperator = variableCreator;
+            variableCreator.Successor = ssp1;
+            ssp1.Operators.Add(analyzer1);
+            ssp1.Successor = ssp2;
+            analyzer1.Successor = null;
+            ssp2.Operators.Add(resultsCollector);
+            ssp2.Successor = mainProcessor;
+            resultsCollector.Successor = null;
+            mainProcessor.Operators.Add(moveGenerator);
+            mainProcessor.Successor = iterationsCounter;
+            moveGenerator.Successor = moveEvaluationProcessor;
+            moveEvaluationProcessor.Operators.Add(moveEvaluator);
+            moveEvaluationProcessor.Successor = evaluatedMovesCounter;
+            moveEvaluator.Successor = qualityComparator;
+            qualityComparator.Successor = acceptsQualityBranch;
+            acceptsQualityBranch.TrueBranch = moveMaker;
+            acceptsQualityBranch.FalseBranch = null;
+            acceptsQualityBranch.Successor = temperatureController;
+            moveMaker.Successor = null;
+            temperatureController.Successor = null;
+            evaluatedMovesCounter.Successor = subScopesRemover;
+            subScopesRemover.Successor = null;
+            iterationsCounter.Successor = iterationsComparator;
+            iterationsComparator.Successor = ssp3;
+            ssp3.Operators.Add(analyzer2);
+            ssp3.Successor = iterationsTermination;
+            iterationsTermination.TrueBranch = null;
+            iterationsTermination.FalseBranch = mainProcessor;
+            #endregion
+        }
+
+        public override IOperation Apply()
+        {
+            if (MoveGeneratorParameter.ActualValue == null || MoveEvaluatorParameter.ActualValue == null || MoveMakerParameter.ActualValue == null)
+                return null;
+            return base.Apply();
+        }
     }
-    public ValueLookupParameter<BoolValue> MaximizationParameter {
-      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
-    }
-    public LookupParameter<DoubleValue> QualityParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-    public ValueLookupParameter<DoubleValue> BestKnownQualityParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
-    }
-    public LookupParameter<DoubleValue> MoveQualityParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
-    }
-    public ILookupParameter<DoubleValue> TemperatureParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Temperature"]; }
-    }
-    public ValueLookupParameter<DoubleValue> StartTemperatureParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["StartTemperature"]; }
-    }
-    public ValueLookupParameter<DoubleValue> EndTemperatureParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["EndTemperature"]; }
-    }
-    public ValueLookupParameter<IntValue> InnerIterationsParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["InnerIterations"]; }
-    }
-    public LookupParameter<IntValue> IterationsParameter {
-      get { return (LookupParameter<IntValue>)Parameters["Iterations"]; }
-    }
-    public ValueLookupParameter<IntValue> MaximumIterationsParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
-    }
-    public ValueLookupParameter<IOperator> MoveGeneratorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["MoveGenerator"]; }
-    }
-    public ValueLookupParameter<IOperator> MoveEvaluatorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["MoveEvaluator"]; }
-    }
-    public ValueLookupParameter<IOperator> MoveMakerParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["MoveMaker"]; }
-    }
-    public ValueLookupParameter<IOperator> AnnealingOperatorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["AnnealingOperator"]; }
-    }
-    public ValueLookupParameter<IOperator> AnalyzerParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
-    }
-    public ValueLookupParameter<VariableCollection> ResultsParameter {
-      get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
-    }
-    public LookupParameter<IntValue> EvaluatedMovesParameter {
-      get { return (LookupParameter<IntValue>)Parameters["EvaluatedMoves"]; }
-    }
-    #endregion
-
-    [StorableConstructor]
-    private SimulatedAnnealingMainLoop(bool deserializing) : base(deserializing) { }
-    private SimulatedAnnealingMainLoop(SimulatedAnnealingMainLoop original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SimulatedAnnealingMainLoop(this, cloner);
-    }
-    public SimulatedAnnealingMainLoop()
-      : base() {
-      Initialize();
-    }
-
-    private void Initialize() {
-      #region Create parameters
-      Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Temperature", "The current temperature."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("StartTemperature", "The initial temperature."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("EndTemperature", "The end temperature."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again)."));
-      Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
-
-      Parameters.Add(new ValueLookupParameter<IOperator>("MoveGenerator", "The operator that generates the moves."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("MoveEvaluator", "The operator that evaluates a move."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("AnnealingOperator", "The operator that modifies the temperature."));
-
-      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
-      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
-      Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of evaluated moves."));
-      #endregion
-
-      #region Create operators
-      Assigner temperatureInitializer = new Assigner();
-      ResultsCollector resultsCollector1 = new ResultsCollector();
-      SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
-      Placeholder analyzer1 = new Placeholder();
-      SubScopesProcessor sssp = new SubScopesProcessor();
-      ResultsCollector resultsCollector = new ResultsCollector();
-      Placeholder annealingOperator = new Placeholder();
-      UniformSubScopesProcessor mainProcessor = new UniformSubScopesProcessor();
-      Placeholder moveGenerator = new Placeholder();
-      UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
-      Placeholder moveEvaluator = new Placeholder();
-      SubScopesCounter subScopesCounter = new SubScopesCounter();
-      ProbabilisticQualityComparator qualityComparator = new ProbabilisticQualityComparator();
-      ConditionalBranch improvesQualityBranch = new ConditionalBranch();
-      Placeholder moveMaker = new Placeholder();
-      SubScopesRemover subScopesRemover = new SubScopesRemover();
-      IntCounter iterationsCounter = new IntCounter();
-      Comparator iterationsComparator = new Comparator();
-      SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
-      Placeholder analyzer2 = new Placeholder();
-      ConditionalBranch iterationsTermination = new ConditionalBranch();
-
-      temperatureInitializer.LeftSideParameter.ActualName = TemperatureParameter.ActualName;
-      temperatureInitializer.RightSideParameter.ActualName = StartTemperatureParameter.Name;
-
-      resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>(IterationsParameter.Name));
-      resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
-
-      analyzer1.Name = "Analyzer (placeholder)";
-      analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
-
-      annealingOperator.Name = "Annealing operator (placeholder)";
-      annealingOperator.OperatorParameter.ActualName = AnnealingOperatorParameter.Name;
-
-      moveGenerator.Name = "Move generator (placeholder)";
-      moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
-
-      moveEvaluator.Name = "Move evaluator (placeholder)";
-      moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
-
-      subScopesCounter.Name = "Increment EvaluatedMoves";
-      subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
-
-      qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
-      qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
-      qualityComparator.ResultParameter.ActualName = "IsBetter";
-      qualityComparator.DampeningParameter.ActualName = "Temperature";
-
-      improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
-
-      moveMaker.Name = "Move maker (placeholder)";
-      moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
-
-      subScopesRemover.RemoveAllSubScopes = true;
-
-      iterationsCounter.Name = "Increment Iterations";
-      iterationsCounter.Increment = new IntValue(1);
-      iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
-
-      iterationsComparator.Name = "Iterations >= MaximumIterations";
-      iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
-      iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
-      iterationsComparator.ResultParameter.ActualName = "Terminate";
-      iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
-
-      analyzer2.Name = "Analyzer (placeholder)";
-      analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
-
-      iterationsTermination.Name = "Iterations termination condition";
-      iterationsTermination.ConditionParameter.ActualName = "Terminate";
-      #endregion
-
-      #region Create operator graph
-      OperatorGraph.InitialOperator = temperatureInitializer;
-      temperatureInitializer.Successor = resultsCollector1;
-      resultsCollector1.Successor = subScopesProcessor0;
-      subScopesProcessor0.Operators.Add(analyzer1);
-      subScopesProcessor0.Successor = sssp;
-      analyzer1.Successor = null;
-      sssp.Operators.Add(resultsCollector);
-      sssp.Successor = annealingOperator;
-      resultsCollector.Successor = null;
-      annealingOperator.Successor = mainProcessor;
-      mainProcessor.Operator = moveGenerator;
-      mainProcessor.Successor = iterationsCounter;
-      moveGenerator.Successor = moveEvaluationProcessor;
-      moveEvaluationProcessor.Operator = moveEvaluator;
-      moveEvaluationProcessor.Successor = subScopesCounter;
-      moveEvaluator.Successor = qualityComparator;
-      qualityComparator.Successor = improvesQualityBranch;
-      improvesQualityBranch.TrueBranch = moveMaker;
-      improvesQualityBranch.FalseBranch = null;
-      improvesQualityBranch.Successor = null;
-      moveMaker.Successor = null;
-      subScopesCounter.Successor = subScopesRemover;
-      subScopesRemover.Successor = null;
-      iterationsCounter.Successor = iterationsComparator;
-      iterationsComparator.Successor = subScopesProcessor1;
-      subScopesProcessor1.Operators.Add(analyzer2);
-      subScopesProcessor1.Successor = iterationsTermination;
-      iterationsTermination.TrueBranch = null;
-      iterationsTermination.FalseBranch = annealingOperator;
-      #endregion
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      // BackwardsCompatibility3.3
-      #region Backwards compatible code (remove with 3.4)
-      if (!Parameters.ContainsKey("Iterations"))
-        Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations."));
-      if (!Parameters.ContainsKey("Temperature"))
-        Parameters.Add(new LookupParameter<DoubleValue>("Temperature", "The current temperature."));
-      #endregion
-    }
-
-    public override IOperation Apply() {
-      if (MoveGeneratorParameter.ActualValue == null || MoveEvaluatorParameter.ActualValue == null || MoveMakerParameter.ActualValue == null)
-        return null;
-      return base.Apply();
-    }
-  }
 }
Index: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureController.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureController.cs	(revision 15295)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureController.cs	(revision 15295)
@@ -0,0 +1,144 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("TemperatureController", "Responsible to first initialize the temperature and then control the temperature.")]
+    [StorableClass]
+    public class TemperatureController : SingleSuccessorOperator
+    {
+        #region Strings
+        private const string ReheatingOperatorName = "ReheatingOperator";
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string MaximumIterationsName = "MaximumIterations";
+        private const string InitialTemperatureName = "InitialTemperature";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string CoolingName = "Cooling";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string ConsecutiveRejectedSolutionsCountName = "ConsecutiveRejectedSolutions";
+        private const string AverageAcceptanceRatioName = "AverageAcceptanceRatio";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string LastQualityName = "LastQuality";
+        private const string UphillMovesMemoryName = "UphillMovesMemory";
+        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";
+        private const string TemperatureInitializedName = "TemperatureInitialized";
+        #endregion
+
+        #region Parameter Properties
+        public IValueLookupParameter<IReheatingOperator> ReheatingOperatorParameter
+        {
+            get { return (IValueLookupParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
+        }
+        public IValueLookupParameter<ITemperatureInitializer> TemperatureInitializerParameter
+        {
+            get { return (IValueLookupParameter<ITemperatureInitializer>)Parameters[TemperatureInitializerName]; }
+        }
+        public ILookupParameter<BoolValue> TemperatureInitializedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[TemperatureInitializedName]; }
+        }
+        #endregion
+
+        [StorableConstructor]
+        protected TemperatureController(bool deserializing) : base(deserializing) { }
+        protected TemperatureController(TemperatureController original, Cloner cloner) : base(original, cloner) { }
+        public TemperatureController()
+          : base()
+        {
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            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<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."));
+            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."));
+            Parameters.Add(new LookupParameter<BoolValue>(IsAcceptedName, "Whether the move was accepted or not."));
+            Parameters.Add(new LookupParameter<ItemList<BoolValue>>(AcceptanceMemoryName, "Memorizes the last N acceptance decisions."));
+            Parameters.Add(new LookupParameter<DoubleValue>(InitialTemperatureName, "The initial temperature."));
+
+            Parameters.Add(new LookupParameter<ItemList<DoubleValue>>(UphillMovesMemoryName, "Memorizes the last 100 uphill moves."));
+            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<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."));
+
+        }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new TemperatureController(this, cloner);
+        }
+
+        public override IOperation Apply()
+        {
+
+            if (!TemperatureInitializedParameter.ActualValue.Value)
+            {
+                return new OperationCollection
+                {
+                    ExecutionContext.CreateOperation(TemperatureInitializerParameter.ActualValue),
+                    base.Apply()
+                };
+            }
+            else
+            {
+                return new OperationCollection {
+                    ExecutionContext.CreateOperation(ReheatingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+            }
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureInitializerBasedOnAverageHillsize.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureInitializerBasedOnAverageHillsize.cs	(revision 15295)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureInitializerBasedOnAverageHillsize.cs	(revision 15295)
@@ -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: /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ValueTemperatureInitializer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ValueTemperatureInitializer.cs	(revision 15295)
+++ /trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ValueTemperatureInitializer.cs	(revision 15295)
@@ -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();
+        }
+    }
+}
