Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/CrowdingAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/CrowdingAnalyzer.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/CrowdingAnalyzer.cs	(revision 14044)
@@ -19,4 +19,6 @@
  */
 #endregion
+
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -29,10 +31,9 @@
   [Item("CrowdingAnalyzer", "The mean crowding distance for each point of the Front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
   public class CrowdingAnalyzer : MOTFAnalyzer {
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-    }
+
     [StorableConstructor]
     protected CrowdingAnalyzer(bool deserializing) : base(deserializing) { }
-    public CrowdingAnalyzer(CrowdingAnalyzer original, Cloner cloner) : base(original, cloner) {
+    public CrowdingAnalyzer(CrowdingAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -40,13 +41,21 @@
     }
 
-
-
     public CrowdingAnalyzer() { }
 
-    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
+    public override IOperation Apply() {
+      var results = ResultsParameter.ActualValue;
+      var qualities = QualitiesParameter.ActualValue;
+      var testFunction = TestFunctionParameter.ActualValue;
       int objectives = qualities[0].Length;
-      if (!results.ContainsKey("Crowding")) results.Add(new Result("Crowding", typeof(DoubleValue)));
-      results["Crowding"].Value = new DoubleValue(Crowding.Calculate(qualities, TestFunctionParameter.ActualValue.Bounds(objectives)));
+
+      if (!results.ContainsKey("Crowding")) results.Add(new Result("Crowding", new DoubleValue()));
+      var resultValue = (DoubleValue)results["Crowding"].Value;
+
+      var crowdingDistance = Crowding.Calculate(qualities.Select(x => x.ToArray()), testFunction.Bounds(objectives));
+      resultValue.Value = crowdingDistance;
+
+      return base.Apply();
     }
+
   }
 }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/GenerationalDistanceAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/GenerationalDistanceAnalyzer.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/GenerationalDistanceAnalyzer.cs	(revision 14044)
@@ -19,4 +19,6 @@
  */
 #endregion
+
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -30,36 +32,41 @@
   [Item("GenerationalDistanceAnalyzer", "The generational distance between the current and the best known front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
   public class GenerationalDistanceAnalyzer : MOTFAnalyzer {
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
+
+    private IFixedValueParameter<DoubleValue> DampeningParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["Dampening"]; }
+      set { Parameters["Dampening"].ActualValue = value; }
     }
+
+    public double Dampening {
+      get { return DampeningParameter.Value.Value; }
+      set { DampeningParameter.Value.Value = value; }
+    }
+
     [StorableConstructor]
     protected GenerationalDistanceAnalyzer(bool deserializing) : base(deserializing) { }
-    public GenerationalDistanceAnalyzer(GenerationalDistanceAnalyzer original, Cloner cloner) : base(original, cloner) {
-    }
+    protected GenerationalDistanceAnalyzer(GenerationalDistanceAnalyzer original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new GenerationalDistanceAnalyzer(this, cloner);
     }
 
-    /// <summary> 
-    /// </summary>
-    private IValueParameter<DoubleValue> DampeningParameter {
-      get {
-        return (IValueParameter<DoubleValue>)Parameters["Dampening"];
-      }
-      set {
-        Parameters["Dampening"].ActualValue = value;
-      }
+    public GenerationalDistanceAnalyzer() {
+      Parameters.Add(new FixedValueParameter<DoubleValue>("Dampening", "", new DoubleValue(1)));
     }
 
-    public GenerationalDistanceAnalyzer() {
-      Parameters.Add(new ValueParameter<DoubleValue>("Dampening", "", new DoubleValue(1)));
-    }
+    public override IOperation Apply() {
+      var results = ResultsParameter.ActualValue;
+      var qualities = QualitiesParameter.ActualValue;
+      int objectives = qualities[0].Length;
 
-    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      int objectives = qualities[0].Length;
       var optimalfront = TestFunctionParameter.ActualValue.OptimalParetoFront(objectives);
-      if (optimalfront == null) return;
-      if (!results.ContainsKey("GenerationalDistance")) results.Add(new Result("GenerationalDistance", typeof(DoubleValue)));
-      results["GenerationalDistance"].Value = new DoubleValue(GenerationalDistance.Calculate(qualities, optimalfront, DampeningParameter.Value.Value));
+      if (optimalfront == null) return base.Apply();
+
+      if (!results.ContainsKey("GenerationalDistance")) results.Add(new Result("GenerationalDistance", new DoubleValue()));
+      var resultValue = (DoubleValue)results["GenerationalDistance"].Value;
+
+      var distance = GenerationalDistance.Calculate(qualities.Select(x => x.ToArray()), optimalfront, Dampening);
+      resultValue.Value = distance;
+
+      return base.Apply();
     }
   }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/HypervolumeAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/HypervolumeAnalyzer.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/HypervolumeAnalyzer.cs	(revision 14044)
@@ -20,5 +20,4 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -32,52 +31,55 @@
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
   [StorableClass]
-  [Item("GenerationalDistanceAnalyzer", "Computes the enclosed Hypervolume between the current front and a given reference Point")]
+  [Item("HypervolumeAnalyzer", "Computes the enclosed Hypervolume between the current front and a given reference Point")]
   public class HypervolumeAnalyzer : MOTFAnalyzer {
+
+    public IValueParameter<DoubleArray> ReferencePointParameter {
+      get { return (IValueParameter<DoubleArray>)Parameters["ReferencePoint"]; }
+    }
+
+    public IFixedValueParameter<DoubleValue> BestKnownHyperVolumeParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["BestKnownHyperVolume"]; }
+    }
+
+    public double BestKnownHyperVolume {
+      get { return BestKnownHyperVolumeParameter.Value.Value; }
+      set { BestKnownHyperVolumeParameter.Value.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected HypervolumeAnalyzer(bool deserializing) : base(deserializing) { }
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      RegisterEventHandlers();
     }
-    [StorableConstructor]
-    protected HypervolumeAnalyzer(bool deserializing) : base(deserializing) { }
-    public HypervolumeAnalyzer(HypervolumeAnalyzer original, Cloner cloner) : base(original, cloner) { }
+
+    protected HypervolumeAnalyzer(HypervolumeAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new HypervolumeAnalyzer(this, cloner);
     }
 
-    public IValueParameter<DoubleArray> ReferencePointParameter {
-      get {
-        return (IValueParameter<DoubleArray>)Parameters["ReferencePoint"];
-      }
-    }
-
-    public IValueParameter<DoubleValue> BestKnownHyperVolumeParameter {
-      get {
-        return (IValueParameter<DoubleValue>)Parameters["BestKnownHyperVolume"];
-      }
-      set {
-        Parameters["BestKnownHyperVolume"].ActualValue = value;
-      }
-    }
-
     public HypervolumeAnalyzer() {
       Parameters.Add(new ValueParameter<DoubleArray>("ReferencePoint", "The reference point for hypervolume calculation"));
-      Parameters.Add(new ValueParameter<DoubleValue>("BestKnownHyperVolume", "The currently best known hypervolume"));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("BestKnownHyperVolume", "The currently best known hypervolume", new DoubleValue(0)));
+
+      RegisterEventHandlers();
     }
 
     private void RegisterEventHandlers() {
-      ReferencePointParameter.ValueChanged += ReferencePointParameterOnValueChanged;
+      ReferencePointParameter.ValueChanged += (o, e) => BestKnownHyperVolume = 0;
     }
 
-    private void ReferencePointParameterOnValueChanged(object sender, EventArgs e) {
-      BestKnownHyperVolumeParameter.Value = new DoubleValue(0);
-    }
-
-    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      if (qualities == null || qualities.Length < 1) return;
+    public override IOperation Apply() {
+      var results = ResultsParameter.ActualValue;
+      var qualities = QualitiesParameter.ActualValue;
+      var testFunction = TestFunctionParameter.ActualValue;
       int objectives = qualities[0].Length;
 
       if (!results.ContainsKey("Hypervolume")) results.Add(new Result("Hypervolume", typeof(DoubleValue)));
       if (!results.ContainsKey("Absolute Distance to BestKnownHypervolume")) results.Add(new Result("Absolute Distance to BestKnownHypervolume", typeof(DoubleValue)));
-      IEnumerable<double[]> front = NonDominatedSelect.selectNonDominatedVectors(qualities, TestFunctionParameter.ActualValue.Maximization(objectives), true);
-      double hv = front.Any() ? Hypervolume.Calculate(front, TestFunctionParameter.ActualValue.ReferencePoint(objectives), TestFunctionParameter.ActualValue.Maximization(objectives)) : 0;
+
       double best;
       if (!results.ContainsKey("BestKnownHypervolume")) {
@@ -87,16 +89,23 @@
         best = ((DoubleValue)(results["BestKnownHypervolume"].Value)).Value;
       }
-      if (Double.IsNaN(best)) best = hv; else best = Math.Max(best, hv);
 
-      double diff = best - hv;
-      if (diff == 0) {
-        BestKnownFrontParameter.ActualValue = new DoubleMatrix(MultiObjectiveTestFunctionProblem.To2D(qualities));
+
+      IEnumerable<double[]> front = NonDominatedSelect.selectNonDominatedVectors(qualities.Select(q => q.ToArray()), testFunction.Maximization(objectives), true);
+
+      double hv = front.Any() ? Hypervolume.Calculate(front, testFunction.ReferencePoint(objectives), testFunction.Maximization(objectives)) : 0;
+
+
+      if (double.IsNaN(best) || best < hv) {
+        best = hv;
+        BestKnownFrontParameter.ActualValue = new DoubleMatrix(MultiObjectiveTestFunctionProblem.To2D(qualities.Select(q => q.ToArray()).ToArray()));
       }
 
       results["Hypervolume"].Value = new DoubleValue(hv);
-      results["Absolute Distance to BestKnownHypervolume"].Value = new DoubleValue(diff);
       results["BestKnownHypervolume"].Value = new DoubleValue(best);
+      results["Absolute Distance to BestKnownHypervolume"].Value = new DoubleValue(best - hv);
 
+      return base.Apply();
     }
+
   }
 }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/InvertedGenerationalDistanceAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/InvertedGenerationalDistanceAnalyzer.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/InvertedGenerationalDistanceAnalyzer.cs	(revision 14044)
@@ -20,4 +20,5 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -31,38 +32,45 @@
   [Item("InvertedGenerationalDistanceAnalyzer", "The inverted generational distance between the current and the best known front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
   public class InvertedGenerationalDistanceAnalyzer : MOTFAnalyzer {
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
+
+
+    private IFixedValueParameter<DoubleValue> DampeningParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["Dampening"]; }
     }
+
+    public double Dampening {
+      get { return DampeningParameter.Value.Value; }
+      set { DampeningParameter.Value.Value = value; }
+    }
+
+    public InvertedGenerationalDistanceAnalyzer() {
+      Parameters.Add(new FixedValueParameter<DoubleValue>("Dampening", "", new DoubleValue(1)));
+    }
+
     [StorableConstructor]
     protected InvertedGenerationalDistanceAnalyzer(bool deserializing) : base(deserializing) { }
-    public InvertedGenerationalDistanceAnalyzer(InvertedGenerationalDistanceAnalyzer original, Cloner cloner) : base(original, cloner) {
-    }
-
+    protected InvertedGenerationalDistanceAnalyzer(InvertedGenerationalDistanceAnalyzer original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new InvertedGenerationalDistanceAnalyzer(this, cloner);
     }
 
-    /// <summary> 
-    /// </summary>
-    private IValueParameter<DoubleValue> DampeningParameter {
-      get {
-        return (IValueParameter<DoubleValue>)Parameters["Dampening"];
-      }
-      set {
-        Parameters["Dampening"].ActualValue = value;
-      }
+    public override IOperation Apply() {
+      var results = ResultsParameter.ActualValue;
+      var qualities = QualitiesParameter.ActualValue;
+      var testFunction = TestFunctionParameter.ActualValue;
+      int objectives = qualities[0].Length;
+
+      var optimalfront = TestFunctionParameter.ActualValue.OptimalParetoFront(objectives);
+      if (optimalfront == null) return base.Apply();
+
+      if (!results.ContainsKey("InvertedGenerationalDistance")) results.Add(new Result("InvertedGenerationalDistance", new DoubleValue(double.NaN)));
+      var resultValue = (DoubleValue)results["InvertedGenerationalDistance"].Value;
+
+      var invertedGenerationalDistance = InvertedGenerationalDistance.Calculate(qualities.Select(q => q.ToArray()), optimalfront, DampeningParameter.Value.Value);
+      resultValue.Value = invertedGenerationalDistance;
+
+      return base.Apply();
     }
 
-    public InvertedGenerationalDistanceAnalyzer() {
-      Parameters.Add(new ValueParameter<DoubleValue>("Dampening", "", new DoubleValue(1)));
-    }
 
-    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      int objectives = qualities[0].Length;
-      var optimalfront = TestFunctionParameter.ActualValue.OptimalParetoFront(objectives);
-      if (optimalfront == null) return;
-      if (!results.ContainsKey("InvertedGenerationalDistance")) results.Add(new Result("InvertedGenerationalDistance", typeof(DoubleValue)));
-      results["InvertedGenerationalDistance"].Value = new DoubleValue(InvertedGenerationalDistance.Calculate(qualities, optimalfront, DampeningParameter.Value.Value));
-    }
   }
 }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/MOTFAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/MOTFAnalyzer.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/MOTFAnalyzer.cs	(revision 14044)
@@ -20,6 +20,4 @@
 #endregion
 
-using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -35,8 +33,5 @@
   [StorableClass]
   public abstract class MOTFAnalyzer : SingleSuccessorOperator, IMultiObjectiveTestFunctionAnalyzer {
-
-    public ILookupParameter<IEncoding> EncodingParameter {
-      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
-    }
+    public bool EnabledByDefault { get { return true; } }
 
     public IScopeTreeLookupParameter<DoubleArray> QualitiesParameter {
@@ -49,21 +44,16 @@
 
     public ILookupParameter<IMultiObjectiveTestFunction> TestFunctionParameter {
-      get {
-        return (ILookupParameter<IMultiObjectiveTestFunction>)Parameters["TestFunction"];
-      }
+      get { return (ILookupParameter<IMultiObjectiveTestFunction>)Parameters["TestFunction"]; }
     }
 
     public ILookupParameter<DoubleMatrix> BestKnownFrontParameter {
-      get {
-        return (ILookupParameter<DoubleMatrix>)Parameters["BestKnownFront"];
-      }
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["BestKnownFront"]; }
     }
 
-    protected MOTFAnalyzer(MOTFAnalyzer original, Cloner cloner) : base(original, cloner) {
-    }
+    protected MOTFAnalyzer(MOTFAnalyzer original, Cloner cloner) : base(original, cloner) { }
+
     [StorableConstructor]
     protected MOTFAnalyzer(bool deserializing) : base(deserializing) { }
-    public MOTFAnalyzer() {
-      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+    protected MOTFAnalyzer() {
       Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>("Qualities", "The qualities of the parameter vector."));
       Parameters.Add(new LookupParameter<ResultCollection>("Results", "The results collection to write to."));
@@ -71,28 +61,4 @@
       Parameters.Add(new LookupParameter<DoubleMatrix>("BestKnownFront", "The currently best known Pareto front"));
     }
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-    }
-
-    public bool EnabledByDefault {
-      get { return true; }
-    }
-
-    public override IOperation Apply() {
-      var encoding = EncodingParameter.ActualValue;
-      var results = ResultsParameter.ActualValue;
-
-      IEnumerable<IScope> scopes = new[] { ExecutionContext.Scope };
-      for (var i = 0; i < QualitiesParameter.Depth; i++)
-        scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b));
-
-      var individuals = scopes.Select(encoding.GetIndividual).ToArray();
-      if (individuals.Length > 0) {
-        Analyze(individuals, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results);
-      }
-      return base.Apply();
-    }
-
-    public abstract void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results);
   }
 }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/NormalizedHypervolumeAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/NormalizedHypervolumeAnalyzer.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/NormalizedHypervolumeAnalyzer.cs	(revision 14044)
@@ -32,18 +32,6 @@
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
   [StorableClass]
-  [Item("GenerationalDistanceAnalyzer", "Computes the enclosed Hypervolume between the current front and a given reference Point")]
+  [Item("NormalizedHypervolumeAnalyzer", "Computes the enclosed Hypervolume between the current front and a given reference Point")]
   public class NormalizedHypervolumeAnalyzer : MOTFAnalyzer {
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-    }
-    [StorableConstructor]
-    protected NormalizedHypervolumeAnalyzer(bool deserializing) : base(deserializing) { }
-    public NormalizedHypervolumeAnalyzer(NormalizedHypervolumeAnalyzer original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new NormalizedHypervolumeAnalyzer(this, cloner);
-    }
-
-
-    #region Names
     private const string bestKnownFront = "BestKnownFront Zitzler";
     private const string resultsHV = "NormalizedHypervolume";
@@ -51,27 +39,27 @@
 
     private const string bestknownHV = "NormalizedBestKnownHyperVolume";
-    #endregion
 
-    #region parameters
     public IValueParameter<DoubleMatrix> OptimalFrontParameter {
-      get {
-        return (IValueParameter<DoubleMatrix>)Parameters[bestKnownFront];
-      }
+      get { return (IValueParameter<DoubleMatrix>)Parameters[bestKnownFront]; }
     }
 
     public IValueParameter<DoubleValue> BestKnownHyperVolumeParameter {
-      get {
-        return (IValueParameter<DoubleValue>)Parameters[bestknownHV];
-      }
-      set {
-        Parameters[bestknownHV].ActualValue = value;
-      }
+      get { return (IValueParameter<DoubleValue>)Parameters[bestknownHV]; }
     }
-    #endregion
 
-    public NormalizedHypervolumeAnalyzer() {
-      if (!Parameters.ContainsKey(bestKnownFront)) Parameters.Add(new ValueParameter<DoubleMatrix>(bestKnownFront, "The true / best known pareto front"));
-      if (!Parameters.ContainsKey(bestknownHV)) Parameters.Add(new ValueParameter<DoubleValue>(bestknownHV, "The currently best known hypervolume"));
+
+    public NormalizedHypervolumeAnalyzer()
+      : base() {
+      Parameters.Add(new ValueParameter<DoubleMatrix>(bestKnownFront, "The true / best known pareto front"));
+      Parameters.Add(new ValueParameter<DoubleValue>(bestknownHV, "The currently best known hypervolume"));
     }
+
+    [StorableConstructor]
+    protected NormalizedHypervolumeAnalyzer(bool deserializing) : base(deserializing) { }
+    protected NormalizedHypervolumeAnalyzer(NormalizedHypervolumeAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NormalizedHypervolumeAnalyzer(this, cloner);
+    }
+
 
     private void RegisterEventHandlers() {
@@ -83,13 +71,16 @@
     }
 
-    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      if (qualities == null || qualities.Length < 1) return;
+    public override IOperation Apply() {
+      var results = ResultsParameter.ActualValue;
+      var qualities = QualitiesParameter.ActualValue;
+      var testFunction = TestFunctionParameter.ActualValue;
       int objectives = qualities[0].Length;
+
       double best = BestKnownHyperVolumeParameter.Value.Value;
       if (OptimalFrontParameter.Value == null || OptimalFrontParameter.Value.Rows < 1 || OptimalFrontParameter.Value.Columns != qualities[0].Length) {
-        return; // too pareto front nonexistant or with wrong number of dimensions
+        return base.Apply(); // too pareto front nonexistant or with wrong number of dimensions
       }
 
-      IEnumerable<double[]> front = NonDominatedSelect.selectNonDominatedVectors(qualities, TestFunctionParameter.ActualValue.Maximization(objectives), true);
+      IEnumerable<double[]> front = NonDominatedSelect.selectNonDominatedVectors(qualities.Select(q => q.ToArray()), testFunction.Maximization(objectives), true);
 
       if (!results.ContainsKey(resultsHV)) results.Add(new Result(resultsHV, typeof(DoubleValue)));
@@ -101,5 +92,5 @@
       }
 
-      bool[] maximization = TestFunctionParameter.ActualValue.Maximization(objectives);
+      bool[] maximization = testFunction.Maximization(objectives);
       double[] invPoint = GetBestPoint(OptimalFrontParameter.Value, maximization);
       double[] refPoint = GetWorstPoint(OptimalFrontParameter.Value, maximization);
@@ -107,18 +98,18 @@
       double hv = front.Any() ? Hypervolume.Calculate(front, refPoint, maximization) / normalization : 0;
 
-      if (Double.IsNaN(best)) best = hv; else best = Math.Max(best, hv);
-      double diff;
-      diff = best - hv;
-      if (diff == 0) {
-        BestKnownFrontParameter.ActualValue = new DoubleMatrix(MultiObjectiveTestFunctionProblem.To2D(qualities));
+      if (double.IsNaN(best) || best < hv) {
+        best = hv;
+        BestKnownFrontParameter.ActualValue = new DoubleMatrix(MultiObjectiveTestFunctionProblem.To2D(qualities.Select(q => q.ToArray()).ToArray()));
       }
 
       results[resultsHV].Value = new DoubleValue(hv);
-      results[resultsDist].Value = new DoubleValue(diff);
       results[bestknownHV].Value = new DoubleValue(best);
+      results[resultsDist].Value = new DoubleValue(best - hv);
 
+      return base.Apply();
     }
 
-    private double[] GetWorstPoint(DoubleMatrix value, bool[] maximization) {
+
+    private static double[] GetWorstPoint(DoubleMatrix value, bool[] maximization) {
       bool[] invMax = new bool[maximization.Length];
       int i = 0;
@@ -129,5 +120,5 @@
     }
 
-    private double[] GetBestPoint(DoubleMatrix value, bool[] maximization) {
+    private static double[] GetBestPoint(DoubleMatrix value, bool[] maximization) {
       double[] res = new double[maximization.Length];
       for (int i = 0; i < maximization.Length; i++) {
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/ScatterPlotAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/ScatterPlotAnalyzer.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/ScatterPlotAnalyzer.cs	(revision 14044)
@@ -19,4 +19,5 @@
  */
 #endregion
+
 using System.Linq;
 using HeuristicLab.Common;
@@ -24,4 +25,5 @@
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -31,26 +33,25 @@
   public class ScatterPlotAnalyzer : MOTFAnalyzer {
 
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
+    public IScopeTreeLookupParameter<RealVector> IndividualsParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["Individuals"]; }
     }
+
     [StorableConstructor]
     protected ScatterPlotAnalyzer(bool deserializing) : base(deserializing) { }
-    public ScatterPlotAnalyzer(ScatterPlotAnalyzer original, Cloner cloner) : base(original, cloner) {
-    }
+    protected ScatterPlotAnalyzer(ScatterPlotAnalyzer original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new ScatterPlotAnalyzer(this, cloner);
     }
 
-    public ScatterPlotAnalyzer() { }
+    public ScatterPlotAnalyzer() {
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("Individuals", "The individual solutions to the problem"));
+    }
 
-    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      if (qualities == null || qualities.Length < 1) return;
+    public override IOperation Apply() {
+      var results = ResultsParameter.ActualValue;
+      var qualities = QualitiesParameter.ActualValue;
+      var testFunction = TestFunctionParameter.ActualValue;
       int objectives = qualities[0].Length;
-      double[][] opf = new double[0][];
-      var optmialFront = TestFunctionParameter.ActualValue.OptimalParetoFront(objectives);
-
-      if (optmialFront != null) opf = optmialFront.Select(s => s.ToArray()).ToArray();
-      var qualityClones = qualities.Select(s => s.ToArray()).ToArray();
-      var solutionClones = individuals.Select(s => s.RealVector().ToArray()).ToArray();
+      var individuals = IndividualsParameter.ActualValue;
 
       if (!results.ContainsKey("Scatterplot")) {
@@ -58,5 +59,14 @@
       }
 
-      results["Scatterplot"].Value = new MOSolution(qualityClones, solutionClones, opf, objectives);
+      double[][] optimalFront = new double[0][];
+      var front = testFunction.OptimalParetoFront(objectives);
+      if (front != null) optimalFront = front.ToArray();
+
+      var qualityClones = qualities.Select(s => s.ToArray()).ToArray();
+      var solutionClones = individuals.Select(s => s.ToArray()).ToArray();
+
+      results["Scatterplot"].Value = new MOSolution(qualityClones, solutionClones, optimalFront, objectives);
+
+      return base.Apply();
     }
   }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/SpacingAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/SpacingAnalyzer.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/SpacingAnalyzer.cs	(revision 14044)
@@ -20,4 +20,5 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -30,25 +31,25 @@
   [Item("SpacingAnalyzer", "The spacing of the current front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
   public class SpacingAnalyzer : MOTFAnalyzer {
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-    }
-
     [StorableConstructor]
     protected SpacingAnalyzer(bool deserializing) : base(deserializing) { }
 
-    public SpacingAnalyzer() {
-    }
-
-    public SpacingAnalyzer(SpacingAnalyzer original, Cloner cloner) : base(original, cloner) {
-    }
-
+    protected SpacingAnalyzer(SpacingAnalyzer original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new SpacingAnalyzer(this, cloner);
     }
 
-    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      if (!results.ContainsKey("Spacing")) results.Add(new Result("Spacing", typeof(DoubleValue)));
-      results["Spacing"].Value = new DoubleValue(Spacing.Calculate(qualities));
+    public SpacingAnalyzer() { }
+
+    public override IOperation Apply() {
+      var results = ResultsParameter.ActualValue;
+      var qualities = QualitiesParameter.ActualValue;
+
+      if (!results.ContainsKey("Spacing")) results.Add(new Result("Spacing", new DoubleValue(0)));
+      var resultValue = (DoubleValue)results["Spacing"].Value;
+
+      var spacing = Spacing.Calculate(qualities.Select(q => q.ToArray()));
+      resultValue.Value = spacing;
+
+      return base.Apply();
     }
   }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Interfaces/IMultiObjectiveTestFunctionAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Interfaces/IMultiObjectiveTestFunctionAnalyzer.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Interfaces/IMultiObjectiveTestFunctionAnalyzer.cs	(revision 14044)
@@ -26,14 +26,8 @@
 
   public interface IMultiObjectiveTestFunctionAnalyzer : IAnalyzer, IMultiObjectiveOperator {
-    ILookupParameter<IEncoding> EncodingParameter { get; }
-
     IScopeTreeLookupParameter<DoubleArray> QualitiesParameter { get; }
-
     ILookupParameter<ResultCollection> ResultsParameter { get; }
-
     ILookupParameter<IMultiObjectiveTestFunction> TestFunctionParameter { get; }
-
     ILookupParameter<DoubleMatrix> BestKnownFrontParameter { get; }
-
   }
 }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 14043)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 14044)
@@ -286,11 +286,18 @@
 
 
-        if (analyzer is HypervolumeAnalyzer) {
-          ((HypervolumeAnalyzer)analyzer).ReferencePointParameter.Value = new DoubleArray(TestFunction.ReferencePoint(Objectives));
-          ((HypervolumeAnalyzer)analyzer).BestKnownHyperVolumeParameter.Value = new DoubleValue(TestFunction.BestKnownHypervolume(Objectives));
+        var hyperVolumeAnalyzer = analyzer as HypervolumeAnalyzer;
+        if (hyperVolumeAnalyzer != null) {
+          hyperVolumeAnalyzer.ReferencePointParameter.Value = new DoubleArray(TestFunction.ReferencePoint(Objectives));
+          hyperVolumeAnalyzer.BestKnownHyperVolume = TestFunction.BestKnownHypervolume(Objectives);
         }
 
-        if (analyzer is NormalizedHypervolumeAnalyzer) {
-          ((NormalizedHypervolumeAnalyzer)analyzer).OptimalFrontParameter.ActualValue = (DoubleMatrix)BestKnownFrontParameter.ActualValue;
+        var normalizedHyperVolumeAnalyzer = analyzer as NormalizedHypervolumeAnalyzer;
+        if (normalizedHyperVolumeAnalyzer != null) {
+          normalizedHyperVolumeAnalyzer.OptimalFrontParameter.ActualValue = (DoubleMatrix)BestKnownFrontParameter.ActualValue;
+        }
+
+        var scatterPlotAnalyzer = analyzer as ScatterPlotAnalyzer;
+        if (scatterPlotAnalyzer != null) {
+          scatterPlotAnalyzer.IndividualsParameter.ActualName = Encoding.Name;
         }
 
