Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/AcceptanceRatioReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/AcceptanceRatioReheatingOperator.cs	(revision 14555)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/AcceptanceRatioReheatingOperator.cs	(revision 14555)
@@ -0,0 +1,216 @@
+﻿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.")]
+    [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";
+
+
+        #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<DoubleValue> UpperTemperatureParameter
+        {
+            get { return (ValueParameter<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]; }
+        }
+
+        #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 ValueParameter<DoubleValue>(UpperTemperatureName, "The upper bound of the temperature.", new DoubleValue(100d)));
+            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.2, 0.1)));
+            Parameters.Add(new ValueParameter<IntValue>(MemorySizeName, "The maximum size of the acceptance memory.", new IntValue(100)));
+
+            #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 = UpperTemperatureName;
+                op.EndValueParameter.Value = UpperTemperatureParameter.Value;
+                op.EndValueParameter.Hidden = true;
+            }
+        }
+
+        public override IOperation Apply()
+        {
+
+            var acceptances = AcceptanceMemoryParameter.ActualValue;
+            var cooling = CoolingParameter.ActualValue.Value;
+
+            acceptances.Add(IsAcceptedParameter.ActualValue);
+
+            if (acceptances.Count > MemorySizeParameter.Value.Value) acceptances.RemoveAt(0);
+
+            var ratioStart = ThresholdParameter.Value.Start;
+            var ratioEnd = ThresholdParameter.Value.End;
+            var ratio = acceptances.Average(x => x.Value ? 1.0 : 0.0);
+
+            
+            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.Value.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: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ConnollyReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ConnollyReheatingOperator.cs	(revision 14555)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ConnollyReheatingOperator.cs	(revision 14555)
@@ -0,0 +1,196 @@
+﻿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("ConnollyReheatingOperator", "Reheats the temperature only once after N consecutive solutions are rejected. It reheats to the temperature where the best solutions was found and the temperature stays there.")]
+    [StorableClass]
+    public class ConnollyReheatingOperator : 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 ThresholdName = "Threshold";
+        private const string IdealTemperatureName = "IdealTemperature";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string QualityName = "Quality";
+        private const string CoolingName = "Cooling";
+        private const string ResultsName = "Results";
+
+        private const string BestQualityName = "BestQuality";
+        private const string TemperatureChartName = "Temperature Chart";
+        private const string QualitiesName = "Qualities";
+        private const string OptimalTemperatureName = "Optimal Temperature";
+
+        #endregion
+        #region Parameters
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> EndTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public ILookupParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
+        }
+        public ILookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        private ValueParameter<IntValue> ThresholdParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[ThresholdName]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<ItemList<BoolValue>> AcceptanceMemoryParameter
+        {
+            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
+        }
+        public ILookupParameter<BoolValue> CoolingParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[CoolingName]; }
+        }
+
+        #endregion
+
+        public ConnollyReheatingOperator() : base()
+        {
+            #region Create parameters
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new LookupParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling 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 ValueParameter<IntValue>(ThresholdName, "How many consecutive solutions have to be rejected to trigger the reheat.", new IntValue(10)));
+            Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
+            #endregion
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected ConnollyReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected ConnollyReheatingOperator(ConnollyReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ConnollyReheatingOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+        }
+
+        public override IOperation Apply()
+        {
+            var cooling = CoolingParameter.ActualValue.Value;
+
+            if(cooling)
+            {
+                var acceptances = AcceptanceMemoryParameter.ActualValue;
+                acceptances.Add(IsAcceptedParameter.ActualValue);
+
+                if (acceptances.Count > ThresholdParameter.Value.Value) acceptances.RemoveAt(0);
+                var stopCooling = acceptances.Count == ThresholdParameter.Value.Value && !acceptances.Any(x => x.Value);
+
+                if(stopCooling)
+                {
+                    CoolingParameter.ActualValue.Value = false;
+                    return ReheatToIdealTemperature();
+                }else
+                {
+                    return Cool();
+                }
+            }
+            else
+            {
+                return KeepTemperature();
+            }
+        }
+
+        private IOperation ReheatToIdealTemperature()
+        {
+            var algorithm = ExecutionContext.Parent.Parent.Parent;
+            var results = (ResultCollection)algorithm.Scope.Variables[ResultsName].Value;
+            var bestQualitySoFar = (DoubleValue)results[BestQualityName].Value;
+            var temperatures = (DataTable)results[TemperatureChartName].Value;
+            var qualities = (DataTable)results[QualitiesName].Value;
+            var bestQualities = qualities.Rows[BestQualityName];
+            var indexOfBestQuality = bestQualities.Values.IndexOf(bestQualitySoFar.Value);
+            var bestTemperature = temperatures.Rows[TemperatureName].Values[indexOfBestQuality];
+
+            TemperatureParameter.ActualValue.Value = bestTemperature;
+
+            if (!results.ContainsKey(OptimalTemperatureName))
+            {
+                results.Add(new Result(OptimalTemperatureName, new DoubleValue(bestTemperature)));
+            }
+            else
+            {
+                results[OptimalTemperatureName].Value = new DoubleValue(bestTemperature);
+            }
+            return base.Apply();
+        }
+
+        private IOperation Cool()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+
+        private IOperation KeepTemperature()
+        {
+            return base.Apply();
+        }
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ConsecutiveRejectionReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ConsecutiveRejectionReheatingOperator.cs	(revision 14555)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ConsecutiveRejectionReheatingOperator.cs	(revision 14555)
@@ -0,0 +1,157 @@
+﻿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("ConsecutiveRejectionReheatingOperator", "The operator reheats the temperature by x when n consecutive solutions are rejected.")]
+    [StorableClass]
+    public class ConsecutiveRejectionReheatingOperator : 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 ThresholdName = "Threshold";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string AmountName = "Amount";
+
+
+        #endregion
+
+        #region Parameters
+        private ValueParameter<DoubleValue> AmountParameter
+        {
+            get { return (ValueParameter<DoubleValue>)Parameters[AmountName]; }
+        }
+        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<ItemList<BoolValue>> AcceptanceMemoryParameter
+        {
+            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
+        }
+
+        #endregion
+
+        public ConsecutiveRejectionReheatingOperator() : 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<ItemList<BoolValue>>(AcceptanceMemoryName, "Memorizes the last N acceptance decisions."));
+            Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive rejected solutions must occur to trigger a reheat.", new IntValue(10)));
+            Parameters.Add(new ValueParameter<DoubleValue>(AmountName, "The amount the temperature gets increased with every reheat.", new DoubleValue(20d)));
+            
+            #endregion
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected ConsecutiveRejectionReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected ConsecutiveRejectionReheatingOperator(ConsecutiveRejectionReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ConsecutiveRejectionReheatingOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+        }
+
+        public override IOperation Apply()
+        {
+            var acceptances = AcceptanceMemoryParameter.ActualValue;
+
+            acceptances.Add(IsAcceptedParameter.ActualValue);
+
+            if (acceptances.Count > ThresholdParameter.Value.Value) acceptances.RemoveAt(0);
+
+            var heating = acceptances.Count == ThresholdParameter.Value.Value && !acceptances.Any(x => x.Value);
+
+            return heating ? Heat() : Cool();
+        }
+
+        private IOperation Heat()
+        {
+            AcceptanceMemoryParameter.ActualValue.Clear();
+            TemperatureParameter.ActualValue.Value += AmountParameter.Value.Value;
+            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: anches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ContinuousReheater.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ContinuousReheater.cs	(revision 14554)
+++ 	(revision )
@@ -1,202 +1,0 @@
-﻿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;
-
-namespace HeuristicLab.Algorithms.SimulatedAnnealing
-{
-    [Item("Continuous Reheater", "Reheats the temperature continuously, while the acceptance rate of solutions is under the threshold.")]
-    [StorableClass]
-    public class ContinuousReheater : SingleSuccessorOperator, ISimulatedAnnealingHeatingStrategy
-    {
-        #region Strings
-        private const string UpperTemperatureName = "UpperTemperature";
-        private const string ReheatingOperatorName = "ReheatingOperator";
-        private const string ThresholdName = "Threshold";
-        private const string MemorySizeName = "MemorySize";
-
-
-        private const string IterationsName = "Iterations";
-        private const string MaximumIterationsName = "MaximumIterations";
-        private const string TemperatureStartIndexName = "TemperatureStartIndex";
-        private const string StartTemperatureName = "StartTemperature";
-        private const string EndTemperatureName = "EndTemperature";
-        private const string TemperatureName = "Temperature";
-        private const string CoolingName = "Cooling";
-        private const string IsAcceptedName = "IsAccepted";
-        private const string AcceptanceMemoryName = "AcceptanceMemory";
-
-
-        #endregion
-        #region Parameters
-        private ValueParameter<DoubleValue> UpperTemperatureParameter
-        {
-            get { return (ValueParameter<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<IntValue> IterationsParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
-        }
-        public IValueLookupParameter<IntValue> MaximumIterationsParameter
-        {
-            get { return (IValueLookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
-        }
-        public ILookupParameter<DoubleValue> TemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> EndTemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> StartTemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
-        }
-        public ILookupParameter<IntValue> TemperatureStartIndexParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
-        }
-        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]; }
-        }
-
-        #endregion
-        #region Properties
-        public DoubleValue UpperTemperature
-        {
-            get { return UpperTemperatureParameter.Value; }
-            set { UpperTemperatureParameter.Value = value; }
-        }
-        public IDiscreteDoubleValueModifier ReheatingOperator
-        {
-            get { return ReheatingOperatorParameter.Value; }
-            set { ReheatingOperatorParameter.Value = value; }
-        }
-        public DoubleRange AcceptanceThreshold
-        {
-            get { return ThresholdParameter.Value; }
-            set { ThresholdParameter.Value = value; }
-        }
-        public IntValue AcceptanceMemorySize
-        {
-            get { return MemorySizeParameter.Value; }
-            set { MemorySizeParameter.Value = value; }
-        }
-        #endregion
-
-        public ContinuousReheater() : base()
-        {
-            #region Create parameters
-            Parameters.Add(new ValueParameter<DoubleValue>(UpperTemperatureName, "The upper bound of the temperature.", new DoubleValue(100d)));
-            Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>(ReheatingOperatorName, "Reheating operator."));
-            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.1, 0.05)));
-            Parameters.Add(new ValueParameter<IntValue>(MemorySizeName, "The maximum size of the acceptance memory.", new IntValue(100)));
-
-            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
-            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
-            Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
-            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."));
-            #endregion
-
-            foreach (var op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
-            {
-                ReheatingOperatorParameter.ValidValues.Add(op);
-            }
-
-            Parameterize();
-        }
-
-        [StorableConstructor]
-        protected ContinuousReheater(bool deserializing) : base(deserializing) { }
-        protected ContinuousReheater(ContinuousReheater original, Cloner cloner) : base(original, cloner) { }
-
-
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new ContinuousReheater(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 bool ShouldReheat(bool cooling, ItemList<BoolValue> acceptances) {
-
-            if (acceptances.Count > MemorySizeParameter.Value.Value) acceptances.RemoveAt(0);
-
-            var ratioStart = ThresholdParameter.Value.Start;
-            var ratioEnd = ThresholdParameter.Value.End;
-            var ratio = acceptances.Average(x => x.Value ? 1.0 : 0.0);
-            if (!cooling && ratio >= ratioEnd)
-            {
-                return false;
-            }
-            else if (cooling && ratio <= ratioStart)
-            {  // temperature is cooled, but should be heated
-                return true;
-            }
-            return !cooling;
-        }
-        public override IOperation Apply()
-        {
-            var iterations = IterationsParameter.ActualValue.Value;
-            TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, iterations - 1);
-            StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
-            EndTemperatureParameter.ActualValue.Value = UpperTemperatureParameter.Value.Value;
-
-            return new OperationCollection {
-                   ExecutionContext.CreateOperation(ReheatingOperatorParameter.Value), base.Apply()};
-        }
-    }
-}
Index: anches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/FixedReheater.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/FixedReheater.cs	(revision 14554)
+++ 	(revision )
@@ -1,94 +1,0 @@
-﻿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;
-
-namespace HeuristicLab.Algorithms.SimulatedAnnealing
-{
-    [Item("Fixed Reheater", "Increases temperature by a fixed amount, each time n consecutive solutions are not accepted.")]
-    [StorableClass]
-    public class FixedReheater : SingleSuccessorOperator, ISimulatedAnnealingHeatingStrategy
-    {
-        #region Strings
-        private const string AmountName = "Amount";
-        private const string ThresholdName = "Threshold";
-        private const string TemperatureName = "Temperature";
-        private const string AcceptanceMemoryName = "AcceptanceMemory";
-
-
-        #endregion
-        #region Parameters
-        private ValueParameter<DoubleValue> AmountParameter
-        {
-            get { return (ValueParameter<DoubleValue>)Parameters[AmountName]; }
-        }
-        private ValueParameter<IntValue> ThresholdParameter
-        {
-            get { return (ValueParameter<IntValue>)Parameters[ThresholdName]; }
-        }
-        public ILookupParameter<DoubleValue> TemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
-        }
-        public ILookupParameter<ItemList<BoolValue>> AcceptanceMemoryParameter
-        {
-            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
-        }
-
-        #endregion
-        #region Properties
-        public DoubleValue Amount
-        {
-            get { return AmountParameter.Value; }
-            set { AmountParameter.Value = value; }
-        }
-        public IntValue AcceptanceThreshold
-        {
-            get { return ThresholdParameter.Value; }
-            set { ThresholdParameter.Value = value; }
-        }
-        #endregion
-
-        public FixedReheater() : base()
-        {
-            #region Create parameters
-            Parameters.Add(new ValueParameter<DoubleValue>(AmountName, "The amount the temperature gets increased with every reheat.", new DoubleValue(20d)));
-            Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "Amount of consecutive rejected solutions that will trigger a reheat.", new IntValue(5)));
-            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
-            Parameters.Add(new LookupParameter<ItemList<BoolValue>>(AcceptanceMemoryName, "Memorizes the last N acceptance decisions."));
-            #endregion
-        }
-
-        [StorableConstructor]
-        protected FixedReheater(bool deserializing) : base(deserializing) { }
-        protected FixedReheater(FixedReheater original, Cloner cloner) : base(original, cloner) { }
-
-
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new FixedReheater(this, cloner);
-        }
-
-        public void Parameterize() { }
-
-        public bool ShouldReheat(bool cooling, ItemList<BoolValue> acceptances) {
-            if (acceptances.Count > ThresholdParameter.Value.Value) acceptances.RemoveAt(0);
-            return acceptances.Count == ThresholdParameter.Value.Value && !acceptances.Any(x => x.Value);
-        }
-        public override IOperation Apply()
-        {
-            AcceptanceMemoryParameter.ActualValue.Clear();
-            TemperatureParameter.ActualValue.Value += AmountParameter.Value.Value;
-            return base.Apply();
-        }
-    }
-}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj	(revision 14554)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj	(revision 14555)
@@ -114,8 +114,10 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ISimulatedAnnealingHeatingStrategy.cs" />
+    <Compile Include="AcceptanceRatioReheatingOperator.cs" />
+    <Compile Include="ConnollyReheatingOperator.cs" />
+    <Compile Include="ConsecutiveRejectionReheatingOperator.cs" />
+    <Compile Include="NoReheatingOperator.cs" />
+    <Compile Include="IReheatingOperator.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="FixedReheater.cs" />
-    <Compile Include="ContinuousReheater.cs" />
     <Compile Include="SimulatedAnnealingImprovementOperator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.user
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.user	(revision 14555)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.user	(revision 14555)
@@ -0,0 +1,6 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectView>ShowAllFiles</ProjectView>
+  </PropertyGroup>
+</Project>
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/IReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/IReheatingOperator.cs	(revision 14555)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/IReheatingOperator.cs	(revision 14555)
@@ -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: anches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ISimulatedAnnealingHeatingStrategy.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ISimulatedAnnealingHeatingStrategy.cs	(revision 14554)
+++ 	(revision )
@@ -1,17 +1,0 @@
-﻿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 ISimulatedAnnealingHeatingStrategy : IOperator
-    {
-        void Parameterize();
-
-        bool ShouldReheat(bool currentCoolingState, ItemList<BoolValue> accepts);
-    }
-}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/NoReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/NoReheatingOperator.cs	(revision 14555)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/NoReheatingOperator.cs	(revision 14555)
@@ -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: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs	(revision 14554)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs	(revision 14555)
@@ -48,5 +48,5 @@
         private const string MoveMakerName = "MoveMaker";
         private const string AnnealingOperatorName = "AnnealingOperator";
-        private const string HeatingStrategyOperatorName = "HeatingStrategyOperator";
+        private const string ReheatingOperatorName = "ReheatingOperator";
         private const string MaximumIterationsName = "MaximumIterations";
         private const string InitialTemperatureName = "InitialTemperature";
@@ -105,7 +105,8 @@
             get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
         }
-        public OptionalConstrainedValueParameter<ISimulatedAnnealingHeatingStrategy> HeatingStrategyOperatorParameter
-        {
-            get { return (OptionalConstrainedValueParameter<ISimulatedAnnealingHeatingStrategy>)Parameters[HeatingStrategyOperatorName]; }
+
+        public IConstrainedValueParameter<IReheatingOperator> ReheatingOperatorParameter
+        {
+            get { return (IConstrainedValueParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
         }
 
@@ -159,8 +160,9 @@
             set { AnnealingOperatorParameter.Value = value; }
         }
-        public ISimulatedAnnealingHeatingStrategy HeatingStrategyOperator
-        {
-            get { return HeatingStrategyOperatorParameter.Value; }
-            set { HeatingStrategyOperatorParameter.Value = value; }
+
+        public IReheatingOperator ReheatingOperator
+        {
+            get { return ReheatingOperatorParameter.Value; }
+            set { ReheatingOperatorParameter.Value = value; }
         }
 
@@ -215,5 +217,5 @@
             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 OptionalConstrainedValueParameter<ISimulatedAnnealingHeatingStrategy>(HeatingStrategyOperatorName, "1The operator used to heat the temperature."));
+            Parameters.Add(new ConstrainedValueParameter<IReheatingOperator>(ReheatingOperatorName, "The operator used to reheat the temperature, if necessary."));
             Parameters.Add(new ValueParameter<IntValue>(MaximumIterationsName, "The maximum number of generations which should be processed.", new IntValue(10000)));
             Parameters.Add(new ValueParameter<DoubleValue>(InitialTemperatureName, "The initial temperature.", new DoubleValue(100)));
@@ -274,5 +276,4 @@
             mainLoop.EndTemperatureParameter.ActualName = EndTemperatureName;
             mainLoop.EvaluatedMovesParameter.ActualName = EvaluatedMovesName;
-            mainLoop.HeatingStrategyOperatorParameter.ActualName = HeatingStrategyOperatorParameter.Name;
 
             mainLoop.IterationsParameter.ActualName = IterationsName;
@@ -287,12 +288,13 @@
             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<ISimulatedAnnealingHeatingStrategy>().OrderBy(x => x.Name))
-            {
-                HeatingStrategyOperatorParameter.ValidValues.Add(op);
             }
 
@@ -568,10 +570,8 @@
                 op.EndValueParameter.Hidden = true;
             }
-            
-            foreach(var op in HeatingStrategyOperatorParameter.ValidValues)
+            foreach (var op in ReheatingOperatorParameter.ValidValues)
             {
                 op.Parameterize();
             }
-
             #endregion
 
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs	(revision 14554)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs	(revision 14555)
@@ -377,5 +377,5 @@
       VariableCreator variableCreator = new VariableCreator();
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(loop.IterationsParameter.ActualName, new IntValue(0)));
-
+        
       variableCreator.Successor = loop;
 
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs	(revision 14554)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs	(revision 14555)
@@ -39,5 +39,5 @@
         private const string MoveMakerName = "MoveMaker";
         private const string AnnealingOperatorName = "AnnealingOperator";
-        private const string HeatingStrategyOperatorName = "HeatingStrategyOperator";
+        private const string ReheatingOperatorName = "ReheatingOperator";
         private const string MaximumIterationsName = "MaximumIterations";
         private const string LowerTemperatureName = "LowerTemperature";
@@ -114,7 +114,7 @@
             get { return (IValueLookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
         }
-        public IValueLookupParameter<IOperator> HeatingStrategyOperatorParameter
-        {
-            get { return (IValueLookupParameter<IOperator>)Parameters[HeatingStrategyOperatorName]; }
+        public IValueLookupParameter<IOperator> ReheatingOperatorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[ReheatingOperatorName]; }
         }
         public IValueLookupParameter<IOperator> AnalyzerParameter
@@ -181,5 +181,5 @@
             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>(HeatingStrategyOperatorName, "The operator that heats the temperature."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(ReheatingOperatorName, "The operator that reheats the temperature if necessary."));
 
             Parameters.Add(new ValueLookupParameter<IOperator>(AnalyzerName, "The operator used to analyze each generation."));
@@ -245,5 +245,5 @@
             temperatureController.CoolingParameter.ActualName = CoolingParameter.Name;
             temperatureController.EndTemperatureParameter.ActualName = EndTemperatureParameter.Name;
-            temperatureController.HeatingStrategyOperatorParameter.ActualName = HeatingStrategyOperatorParameter.Name;
+            temperatureController.ReheatingOperatorParameter.ActualName = ReheatingOperatorParameter.Name;
             temperatureController.IsAcceptedParameter.ActualName = IsAcceptedName;
             temperatureController.IterationsParameter.ActualName = IterationsParameter.Name;
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureController.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureController.cs	(revision 14554)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureController.cs	(revision 14555)
@@ -38,6 +38,6 @@
     {
         #region Strings
+        private const string ReheatingOperatorName = "ReheatingOperator";
         private const string AnnealingOperatorName = "AnnealingOperator";
-        private const string HeatingStrategyOperatorName = "HeatingStrategyOperator";
         private const string MaximumIterationsName = "MaximumIterations";
         private const string LowerTemperatureName = "LowerTemperature";
@@ -89,7 +89,7 @@
             get { return (IValueLookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
         }
-        public IValueLookupParameter<ISimulatedAnnealingHeatingStrategy> HeatingStrategyOperatorParameter
+        public IValueLookupParameter<IReheatingOperator> ReheatingOperatorParameter
         {
-            get { return (IValueLookupParameter<ISimulatedAnnealingHeatingStrategy>)Parameters[HeatingStrategyOperatorName]; }
+            get { return (IValueLookupParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
         }
         public ILookupParameter<BoolValue> IsAcceptedParameter
@@ -114,5 +114,5 @@
             Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
             Parameters.Add(new ValueLookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
-            Parameters.Add(new ValueLookupParameter<ISimulatedAnnealingHeatingStrategy>(HeatingStrategyOperatorName, "The operator that heats 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."));
@@ -130,39 +130,8 @@
         public override IOperation Apply()
         {
-            var iterations = IterationsParameter.ActualValue.Value;
-            var heatingStrategyOperator = HeatingStrategyOperatorParameter.ActualValue;
-            var accepted = IsAcceptedParameter.ActualValue;
-
-            // if there is no heatingstrategyoperator just do cooling     
-            if (accepted == null || heatingStrategyOperator == null)
-            {
-                CoolingParameter.ActualValue.Value = true;
-            }else
-            {
-                // else, let the heatingstrategyoperator decide if it is time to reheat
-                var acceptances = AcceptanceMemoryParameter.ActualValue;
-                acceptances.Add(accepted);
-                CoolingParameter.ActualValue.Value = !heatingStrategyOperator.
-                    ShouldReheat(CoolingParameter.ActualValue.Value, acceptances);
-            }
-
-            // if we want to cool, use the cooling parameter
-            if (CoolingParameter.ActualValue.Value == true)
-            { 
-                TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, iterations - 1);
-                StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
-                EndTemperatureParameter.ActualValue.Value = LowerTemperatureParameter.ActualValue.Value;
-                return new OperationCollection {
-                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(ReheatingOperatorParameter.ActualValue),
                     base.Apply()
                 };
-            }else
-            {
-                // else just use the heating parameter
-                return new OperationCollection {
-                    ExecutionContext.CreateOperation(HeatingStrategyOperatorParameter.ActualValue),
-                    base.Apply()
-                };
-            }
         }
     }
