Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs	(revision 5009)
@@ -5,10 +5,20 @@
 using HeuristicLab.Core;
 using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Parameters;
 using HeuristicLab.Problems.MetaOptimization;
 using HeuristicLab.Data;
 using System;
+using System.Threading;
+using HeuristicLab.Random;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.MetaOptimization.Test {
   class Program {
+    private static int metaAlgorithmPopulationSize = 20;
+    private static int metaAlgorithmMaxGenerations = 100;
+
+    private static int baseAlgorithmPopulationSize = 20;
+    private static int baseAlgorithmMaxGenerations = 30;
+
     static void Main(string[] args) {
       //TestIntSampling();
@@ -17,21 +27,76 @@
       GeneticAlgorithm baseLevelAlgorithm = new GeneticAlgorithm();
       MetaOptimizationProblem metaOptimizationProblem = new MetaOptimizationProblem();
+      GeneticAlgorithm metaLevelAlgorithm = GetMetaAlgorithm(metaOptimizationProblem);
+
+      IValueConfiguration algorithmVc = SetupAlgorithm(baseLevelAlgorithm, metaOptimizationProblem);
+
+      Console.WriteLine("Press enter to start");
+      Console.ReadLine();
+      TestConfiguration(algorithmVc, baseLevelAlgorithm);
+
+      Console.WriteLine("Press enter to start");
+      Console.ReadLine();
+      TestOptimization(metaLevelAlgorithm);
+
+      //TestMemoryLeak(metaLevelAlgorithm);
+
+      Console.ReadLine();
+    }
+
+    private static void TestMemoryLeak(GeneticAlgorithm metaLevelAlgorithm) {
+      IValueConfiguration algorithmVc = ((MetaOptimizationProblem)metaLevelAlgorithm.Problem).AlgorithmParameterConfiguration;
+
+      Console.WriteLine("Starting Memory Test...");
+      Console.ReadLine();
+
+      for (int i = 0; i < 1000; i++) {
+        var clone = algorithmVc.Clone();
+      }
+
+      Console.WriteLine("Finished. Now GC...");
+      Console.ReadLine();
+
+      GC.Collect();
+
+      Console.WriteLine("Finished!");
+      Console.ReadLine();
+    }
+
+    private static GeneticAlgorithm GetMetaAlgorithm(MetaOptimizationProblem metaOptimizationProblem) {
+      GeneticAlgorithm metaLevelAlgorithm = new GeneticAlgorithm();
+      metaLevelAlgorithm.PopulationSize.Value = metaAlgorithmPopulationSize;
+      metaLevelAlgorithm.MaximumGenerations.Value = metaAlgorithmMaxGenerations;
+
+      metaLevelAlgorithm.Problem = metaOptimizationProblem;
+      metaLevelAlgorithm.Engine = new SequentialEngine.SequentialEngine();
+      return metaLevelAlgorithm;
+    }
+
+    private static IValueConfiguration SetupAlgorithm(GeneticAlgorithm baseLevelAlgorithm, MetaOptimizationProblem metaOptimizationProblem) {
+      baseLevelAlgorithm.Problem = new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() { ProblemSize = new IntValue(2000) };
+      baseLevelAlgorithm.PopulationSize.Value = baseAlgorithmPopulationSize;
+      baseLevelAlgorithm.MaximumGenerations.Value = baseAlgorithmMaxGenerations;
+
       metaOptimizationProblem.Algorithm = baseLevelAlgorithm;
       IValueConfiguration algorithmVc = metaOptimizationProblem.AlgorithmParameterConfiguration;
-
-      //ConfigurePopulationSize(algorithmVc);
+      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem());
+
+      ConfigurePopulationSize(algorithmVc);
       ConfigureMutationRate(algorithmVc);
-
-      GeneticAlgorithm metaLevelAlgorithm = new GeneticAlgorithm();
-      metaLevelAlgorithm.PopulationSize.Value = 10;
-
+      ConfigureMutationOperator(algorithmVc);
+      return algorithmVc;
+    }
+
+    private static void TestConfiguration(IValueConfiguration algorithmVc, GeneticAlgorithm baseLevelAlgorithm) {
+      IRandom rand = new MersenneTwister();
       // set random values
       for (int i = 0; i < 10; i++) {
         IValueConfiguration clonedVc = (IValueConfiguration)algorithmVc.Clone();
-        clonedVc.Randomize();
-        clonedVc.Parameterize();
+        clonedVc.Randomize(rand);
+        clonedVc.Parameterize((GeneticAlgorithm)clonedVc.ActualValue.Value);
         GeneticAlgorithm newAlg = (GeneticAlgorithm)clonedVc.ActualValue.Value;
-        //Console.WriteLine(string.Format("PopSize: original: {0}, randomized: {1}", baseLevelAlgorithm.PopulationSize, newAlg.PopulationSize));
+        Console.WriteLine(string.Format("PopSize: original: {0}, randomized: {1}", baseLevelAlgorithm.PopulationSize, newAlg.PopulationSize));
         Console.WriteLine(string.Format("MutRate: original: {0}, randomized: {1}", baseLevelAlgorithm.MutationProbability, newAlg.MutationProbability));
+        Console.WriteLine(string.Format("MutOp: original: {0}, randomized: {1}", baseLevelAlgorithm.Mutator, newAlg.Mutator));
       }
 
@@ -39,9 +104,10 @@
       for (int i = 0; i < 10; i++) {
         IValueConfiguration clonedVc = (IValueConfiguration)algorithmVc.Clone();
-        clonedVc.Mutate();
-        clonedVc.Parameterize();
+        clonedVc.Mutate(rand);
+        clonedVc.Parameterize((GeneticAlgorithm)clonedVc.ActualValue.Value);
         GeneticAlgorithm newAlg = (GeneticAlgorithm)clonedVc.ActualValue.Value;
-        //Console.WriteLine(string.Format("PopSize: original: {0}, mutated: {1}", baseLevelAlgorithm.PopulationSize, newAlg.PopulationSize));
+        Console.WriteLine(string.Format("PopSize: original: {0}, mutated: {1}", baseLevelAlgorithm.PopulationSize, newAlg.PopulationSize));
         Console.WriteLine(string.Format("MutRate: original: {0}, mutated: {1}", baseLevelAlgorithm.MutationProbability, newAlg.MutationProbability));
+        Console.WriteLine(string.Format("MutOp: original: {0}, mutated: {1}", baseLevelAlgorithm.Mutator, newAlg.Mutator));
       }
 
@@ -49,6 +115,6 @@
       for (int i = 0; i < 10; i++) {
         IValueConfiguration clonedVc1 = (IValueConfiguration)algorithmVc.Clone();
-        clonedVc1.Randomize();
-        clonedVc1.Parameterize();
+        clonedVc1.Randomize(rand);
+        clonedVc1.Parameterize(baseLevelAlgorithm);
 
         IValueConfiguration clonedVc2 = (IValueConfiguration)algorithmVc.Clone();
@@ -58,12 +124,24 @@
         var popSizeBefore = first.PopulationSize.Value;
         var mutRateBefore = first.MutationProbability.Value;
-        clonedVc1.Cross(clonedVc2);
-        clonedVc1.Parameterize();
-
-        //Console.WriteLine(string.Format("PopSize: first: {0}, second: {1}, crossed: {2}", popSizeBefore, second.PopulationSize, first.PopulationSize));
+        var mutOpBefore = first.Mutator;
+
+        clonedVc1.Cross(clonedVc2, rand);
+        clonedVc1.Parameterize((GeneticAlgorithm)clonedVc2.ActualValue.Value);
+
+        Console.WriteLine(string.Format("PopSize: first: {0}, second: {1}, crossed: {2}", popSizeBefore, second.PopulationSize, first.PopulationSize));
         Console.WriteLine(string.Format("MutRate: first: {0}, second: {1}, crossed: {2}", mutRateBefore, second.MutationProbability, first.MutationProbability));
-      }
-
-      Debugger.Break();
+        Console.WriteLine(string.Format("MutRate: first: {0}, second: {1}, crossed: {2}", mutOpBefore, second.Mutator, first.Mutator));
+      }
+    }
+
+    private static void ConfigureMutationOperator(IValueConfiguration algorithmVc) {
+      var mutationOperator = algorithmVc.ParameterConfigurations.Where(x => x.Name == "Mutator").SingleOrDefault();
+      mutationOperator.Optimize = true;
+
+      // uncheck multiMutator to avoid Michalewicz issue
+      var multiMutator = mutationOperator.ValueConfigurations.Where(x => x.ActualValue.Value.ItemName.StartsWith("Multi")).SingleOrDefault();
+      if (multiMutator != null) {
+        mutationOperator.ValueConfigurations.SetItemCheckedState(multiMutator, false);
+      }
     }
 
@@ -86,4 +164,31 @@
       mutationRateVc.RangeConstraint.UpperBound = new PercentValue(1.0);
       mutationRateVc.RangeConstraint.StepSize = new PercentValue(0.01);
+    }
+
+    private static void TestOptimization(GeneticAlgorithm metaLevelAlgorithm) {
+      metaLevelAlgorithm.Start();
+      do {
+        Thread.Sleep(1000);
+        Console.Clear();
+        try {
+          foreach (var result in metaLevelAlgorithm.Results) {
+            Console.WriteLine(result.ToString());
+            if (result.Name == "Population") {
+              RunCollection rc = (RunCollection)result.Value;
+              var orderedRuns = rc.OrderBy(x => x.Results["BestQuality"]);
+              foreach (IRun run in orderedRuns) {
+                Console.WriteLine("Q: {0} PoSi: {1} MuRa: {2} MuOp: {3}",
+                  ((DoubleValue)run.Results["BestQuality"]).Value.ToString("0.00").PadLeft(4, ' '),
+                  ((IntValue)run.Parameters["PopulationSize"]).Value.ToString().PadLeft(3, ' '),
+                  ((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.00").PadRight(3, ' '),
+                  run.Parameters["Mutator"]);
+              }
+            }
+          }
+        }
+        catch { }
+      } while (metaLevelAlgorithm.ExecutionState != ExecutionState.Stopped);
+
+      Console.WriteLine("Finished");
     }
 
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/RootValueConfigurationView.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/RootValueConfigurationView.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/RootValueConfigurationView.cs	(revision 5009)
@@ -16,5 +16,5 @@
   /// </summary>
   [View("ParameterConfiguration View")]
-  [Content(typeof(RootValueConfiguration), true)]
+  [Content(typeof(ParameterConfigurationTree), true)]
   public partial class RootValueConfigurationView : ItemView {
     /// <summary>
@@ -23,6 +23,6 @@
     /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
     /// No own data storage present.</remarks>
-    public new RootValueConfiguration Content {
-      get { return (RootValueConfiguration)base.Content; }
+    public new ParameterConfigurationTree Content {
+      get { return (ParameterConfigurationTree)base.Content; }
       set { base.Content = value; }
     }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs	(revision 5009)
@@ -7,4 +7,6 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+using System;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -12,17 +14,17 @@
   /// TODO An operator for analyzing the best solution of Traveling Salesman Problems given in path representation using city coordinates.
   /// </summary>
-  [Item("BestQualityAnalyzer", "TODO An operator for analyzing the best solution of Traveling Salesman Problems given in path representation using city coordinates.")]
+  [Item("BestParameterConfigurationAnalyzer", "TODO An operator for analyzing the best solution of Traveling Salesman Problems given in path representation using city coordinates.")]
   [StorableClass]
   public sealed class BestParameterConfigurationAnalyzer : SingleSuccessorOperator, IAnalyzer {
     // Wagner: Spezielle View für die Lösungen (ParameterConfigurations): So wie bei Runs: die zu Optimierenden Parameter(-werte) der besten solution anzeigen
 
-    public ScopeTreeLookupParameter<IParameterConfiguration> ParameterVectorParameter {
-      get { return (ScopeTreeLookupParameter<IParameterConfiguration>)Parameters["ParameterConfiguration"]; }
+    public ScopeTreeLookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
+      get { return (ScopeTreeLookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
     }
     public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
       get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public LookupParameter<IParameterConfiguration> BestSolutionParameter {
-      get { return (LookupParameter<IParameterConfiguration>)Parameters["BestSolution"]; }
+    public LookupParameter<IRun> BestSolutionParameter {
+      get { return (LookupParameter<IRun>)Parameters["BestSolution"]; }
     }
     public ValueLookupParameter<ResultCollection> ResultsParameter {
@@ -32,15 +34,19 @@
       get { return (LookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
     }
-    public LookupParameter<IParameterConfiguration> BestKnownSolutionParameter {
-      get { return (LookupParameter<IParameterConfiguration>)Parameters["BestKnownSolution"]; }
+    public LookupParameter<IRun> BestKnownSolutionParameter {
+      get { return (LookupParameter<IRun>)Parameters["BestKnownSolution"]; }
+    }
+    public LookupParameter<RunCollection> PopulationParameter {
+      get { return (LookupParameter<RunCollection>)Parameters["Population"]; }
     }
 
     public BestParameterConfigurationAnalyzer() : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<IParameterConfiguration>("ParameterConfiguration", "TODO The TSP solutions given in path representation from which the best solution should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "TODO The TSP solutions given in path representation from which the best solution should be analyzed."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "TODO The qualities of the TSP solutions which should be analyzed."));
-      Parameters.Add(new LookupParameter<IParameterConfiguration>("BestSolution", "TODO The best TSP solution."));
+      Parameters.Add(new LookupParameter<IRun>("BestSolution", "TODO The best TSP solution."));
       Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "TODO The result collection where the best TSP solution should be stored."));
       Parameters.Add(new LookupParameter<DoubleValue>("BestKnownQuality", "TODO The quality of the best known solution of this TSP instance."));
-      Parameters.Add(new LookupParameter<IParameterConfiguration>("BestKnownSolution", "TODO The best known solution of this TSP instance."));
+      Parameters.Add(new LookupParameter<IRun>("BestKnownSolution", "TODO The best known solution of this TSP instance."));
+      Parameters.Add(new LookupParameter<RunCollection>("Population", "TODO The best known solution of this TSP instance."));
     }
 
@@ -56,14 +62,41 @@
       ResultCollection results = ResultsParameter.ActualValue;
       DoubleValue bestKnownQuality = BestKnownQualityParameter.ActualValue;
-      ItemArray<IParameterConfiguration> parameterVectors = ParameterVectorParameter.ActualValue;
+      ItemArray<ParameterConfigurationTree> parameterConfigurations = ParameterConfigurationParameter.ActualValue;
 
       int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
 
+      EngineAlgorithm bestAlg = ((EngineAlgorithm)((ParameterConfigurationTree)parameterConfigurations[i]).ActualValue.Value);
+      Run bestRun = new Run(bestAlg);
+
       if (bestKnownQuality == null || qualities[i].Value < bestKnownQuality.Value) {
         BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[i].Value);
-        BestKnownSolutionParameter.ActualValue = (IParameterConfiguration)parameterVectors[i].Clone();
+        BestKnownSolutionParameter.ActualValue = bestRun;
       }
 
-      // todo: more
+      IRun best = BestSolutionParameter.ActualValue;
+      if (best == null) {
+        BestSolutionParameter.ActualValue = bestRun;
+        results.Add(new Result("Best Parameter Settings", bestRun));
+      } else {
+        BestSolutionParameter.ActualValue = bestRun;
+        results["Best Parameter Settings"].Value = bestRun;
+      }
+
+      RunCollection rc = new RunCollection();
+      
+      foreach (ParameterConfigurationTree pc in parameterConfigurations.OrderBy(x => x.Quality.Value*-1)) {
+        IAlgorithm alg = (IAlgorithm)pc.ActualValue.Value;
+        alg.StoreAlgorithmInEachRun = false;
+        IRun run = new Run(alg);
+        rc.Add(run);
+      }
+      if (PopulationParameter.ActualValue == null) {
+        PopulationParameter.ActualValue = rc;
+        results.Add(new Result("Population", rc));
+      } else {
+        PopulationParameter.ActualValue = rc;
+        results["Population"].Value = rc;
+      }
+      GC.Collect();
 
       return base.Apply();
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Creators/RandomParameterConfigurationCreator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Creators/RandomParameterConfigurationCreator.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Creators/RandomParameterConfigurationCreator.cs	(revision 5009)
@@ -20,10 +20,10 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<IValueConfiguration> ValueConfigurationParameter {
-      get { return (ILookupParameter<IValueConfiguration>)Parameters["ValueConfiguration"]; }
+    public ILookupParameter<ParameterConfigurationTree> InitialParameterConfigurationParameter {
+      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["InitialParameterConfigurationTree"]; }
     }
 
-    public ILookupParameter<IValueConfiguration> NewValueConfigurationParameter {
-      get { return (ILookupParameter<IValueConfiguration>)Parameters["NewValueConfiguration"]; }
+    public ILookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
+      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
     }
 
@@ -33,5 +33,6 @@
     public RandomParameterConfigurationCreator() : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used to initialize the new random permutation."));
-      Parameters.Add(new LookupParameter<IValueConfiguration>("ValueConfiguration", "The new random parameter set."));
+      Parameters.Add(new LookupParameter<ParameterConfigurationTree>("InitialParameterConfigurationTree", "The parameter configuration tree on which the new solution will be based on."));
+      Parameters.Add(new LookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "The new random parameter set."));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -40,7 +41,6 @@
 
     public override IOperation Apply() {
-      NewValueConfigurationParameter.ActualValue = (IValueConfiguration)ValueConfigurationParameter.ActualValue.Clone();
-      NewValueConfigurationParameter.ActualValue.Randomize();
-      NewValueConfigurationParameter.ActualValue.Parameterize();
+      ParameterConfigurationParameter.ActualValue = (ParameterConfigurationTree)InitialParameterConfigurationParameter.ActualValue.Clone();
+      ParameterConfigurationParameter.ActualValue.Randomize(RandomParameter.ActualValue);
       return base.Apply();
     }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/Crossovers/ParameterConfigurationCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/Crossovers/ParameterConfigurationCrossover.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/Crossovers/ParameterConfigurationCrossover.cs	(revision 5009)
@@ -13,5 +13,5 @@
   /// 
   /// </summary>
-  [Item("ParameterVectorCrossover", "TODO")]
+  [Item("ParameterConfigurationCrossover", "TODO")]
   [StorableClass]
   public class ParameterConfigurationCrossover : SingleSuccessorOperator, IParameterConfigurationOperator, ICrossover {
@@ -23,9 +23,9 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<ItemArray<IParameterConfiguration>> ParentsParameter {
-      get { return (ScopeTreeLookupParameter<IParameterConfiguration>)Parameters["Parents"]; }
+    public ILookupParameter<ItemArray<IValueConfiguration>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<IValueConfiguration>)Parameters["Parents"]; }
     }
-    public ILookupParameter<IParameterConfiguration> ChildParameter {
-      get { return (ILookupParameter<IParameterConfiguration>)Parameters["Child"]; }
+    public ILookupParameter<IValueConfiguration> ChildParameter {
+      get { return (ILookupParameter<IValueConfiguration>)Parameters["Child"]; }
     }
 
@@ -47,8 +47,8 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
-      Parameters.Add(new ScopeTreeLookupParameter<IParameterConfiguration>("Parents", "The parent vectors which should be crossed."));
-      ParentsParameter.ActualName = "ParameterConfiguration";
-      Parameters.Add(new LookupParameter<IParameterConfiguration>("Child", "The child vector resulting from the crossover."));
-      ChildParameter.ActualName = "ParameterConfiguration";
+      Parameters.Add(new ScopeTreeLookupParameter<IValueConfiguration>("Parents", "The parent vectors which should be crossed."));
+      ParentsParameter.ActualName = "ParameterConfigurationTree";
+      Parameters.Add(new LookupParameter<IValueConfiguration>("Child", "The child vector resulting from the crossover."));
+      ChildParameter.ActualName = "ParameterConfigurationTree";
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -57,14 +57,9 @@
 
     public override IOperation Apply() {
+      IValueConfiguration child1 = (IValueConfiguration)ParentsParameter.ActualValue[0].Clone();
+      IValueConfiguration child2 = (IValueConfiguration)ParentsParameter.ActualValue[1];
 
-      IParameterConfiguration child = (IParameterConfiguration)ParentsParameter.ActualValue[0].Clone();
-      // todo
-      //for (int i = 0; i < child.Parameters.Count; i++) {
-      //  if (child.Parameters[i].Parameter.DataType == typeof(IntValue)) {
-      //    child.Parameters[i].Parameter.ActualValue = CrossInteger(ParentsParameter.ActualValue[0].Parameters[i], ParentsParameter.ActualValue[1].Parameters[i]);
-      //  }
-      //}
-
-      this.ChildParameter.ActualValue = child;
+      child1.Cross(child2, RandomParameter.ActualValue);
+      this.ChildParameter.ActualValue = child1;
       return base.Apply();
     }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationTree.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationTree.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationTree.cs	(revision 5009)
@@ -0,0 +1,102 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Optimization;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  // todo: storable, name, descr, ...
+  [StorableClass]
+  public class ParameterConfigurationTree : ValueConfiguration {
+    //[Storable]
+    //protected EngineAlgorithm algorithm;
+    //public EngineAlgorithm Algorithm {
+    //  get { return algorithm; }
+    //  set {
+    //    if (algorithm != value) {
+    //      if (algorithm != null) DeregisterAlgorithmEvents();
+    //      algorithm = value;
+    //      if (algorithm != null) RegisterAlgorithmEvents();
+    //      OnAlgorithmChanged();
+    //    }
+    //  }
+    //}
+
+    [Storable]
+    private DoubleValue quality;
+    public DoubleValue Quality {
+      get { return quality; }
+      set {
+        if (quality != value) {
+          if (quality != null) DeregisterQualityEvents();
+          quality = value;
+          if (quality != null) RegisterQualityEvents();
+          OnQualityChanged();
+        }
+      }
+    }
+
+    #region constructors and cloning
+    public ParameterConfigurationTree(EngineAlgorithm algorithm) : base(algorithm, algorithm.GetType()) {
+      this.Optimize = true; // root must always be optimized
+      this.Quality = new DoubleValue();
+      //this.algorithm = algorithm;
+    }
+    public ParameterConfigurationTree() {
+      Initialize();
+    }
+    [StorableConstructor]
+    protected ParameterConfigurationTree(bool deserializing) : base(deserializing) { }
+    protected ParameterConfigurationTree(ParameterConfigurationTree original, Cloner cloner) : base(original, cloner) {
+      this.quality = cloner.Clone(original.Quality);
+      Initialize();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterConfigurationTree(this, cloner);
+    }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+    #endregion
+
+    private void Initialize() {
+      //if (algorithm != null) RegisterAlgorithmEvents();
+      if (quality != null) RegisterQualityEvents();
+    }
+
+    #region Events
+    //public event EventHandler AlgorithmChanged;
+    //private void OnAlgorithmChanged() {
+    //  var handler = AlgorithmChanged;
+    //  if (handler != null) handler(this, EventArgs.Empty);
+    //}
+    public event EventHandler QualityChanged;
+    private void OnQualityChanged() {
+      var handler = QualityChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    //private void RegisterAlgorithmEvents() {
+      
+    //}
+    //private void DeregisterAlgorithmEvents() {
+
+    //}
+    private void RegisterQualityEvents() {
+      Quality.ValueChanged += new EventHandler(Quality_ValueChanged);
+    }
+    private void DeregisterQualityEvents() {
+      Quality.ValueChanged -= new EventHandler(Quality_ValueChanged);
+    }
+
+    private void Quality_ValueChanged(object sender, EventArgs e) {
+      OnQualityChanged();
+    }
+    #endregion
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs	(revision 5009)
@@ -6,4 +6,7 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using System.Collections;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -47,4 +50,5 @@
     }
 
+    [Storable]
     protected Type parameterDataType;
     public Type ParameterDataType {
@@ -52,6 +56,7 @@
     }
 
-    protected IEnumerable<IItem> validValues;
-    public IEnumerable<IItem> ValidValues {
+    [Storable]
+    protected IItemSet<IItem> validValues;
+    public IItemSet<IItem> ValidValues {
       get { return validValues; }
       protected set {
@@ -62,4 +67,5 @@
     }
 
+    [Storable]
     protected Type valueDataType;
     public Type ValueDataType {
@@ -68,4 +74,5 @@
     }
 
+    [Storable]
     protected ICheckedValueConfigurationCollection valueConfigurations;
     public ICheckedValueConfigurationCollection ValueConfigurations {
@@ -80,6 +87,8 @@
     }
 
+    [Storable]
     protected int actualValueConfigurationIndex = 0;
 
+    [Storable]
     protected ConstrainedValue actualValue;
     public ConstrainedValue ActualValue {
@@ -89,5 +98,6 @@
     
     // store parameter reference only for name/description/image/...
-    private IValueParameter parameter;
+    //[Storable]
+    //private IValueParameter parameter;
 
     #region Constructors and Cloning
@@ -95,7 +105,7 @@
       this.ParameterName = parameterName;
       this.parameterDataType = valueParameter.GetType();
-      this.parameter = valueParameter;
+      //this.parameter = valueParameter;
       this.valueDataType = valueParameter.DataType;
-      this.validValues = GetValidValues();
+      this.validValues = GetValidValues(valueParameter);
       this.ValueConfigurations = new CheckedValueConfigurationCollection(this.valueDataType);
       this.ActualValue = new ConstrainedValue(valueParameter.Value, valueParameter.DataType);
@@ -111,13 +121,18 @@
       this.parameterName = original.ParameterName;
       this.parameterDataType = original.parameterDataType;
-      this.parameter = cloner.Clone(original.parameter);
+      //this.parameter = cloner.Clone(original.parameter);
       this.valueDataType = original.ValueDataType;
-      this.validValues = original.ValidValues.Select(x => cloner.Clone(x));
-      this.ValueConfigurations = cloner.Clone(original.ValueConfigurations);
+      this.validValues = cloner.Clone(original.ValidValues);
+      this.valueConfigurations = cloner.Clone(original.ValueConfigurations);
       this.ActualValue = cloner.Clone(original.ActualValue);
       this.optimize = original.optimize;
+      if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
     }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new ParameterConfiguration(this, cloner);
+    }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
     }
     #endregion
@@ -147,6 +162,22 @@
     }
 
-    private IEnumerable<IItem> GetValidValues() {
-      return ApplicationManager.Manager.GetInstances(valueDataType).Select(x => (IItem)x).OrderBy(x => x.ItemName).ToArray();
+    private IItemSet<IItem> GetValidValues(IValueParameter parameter) {
+      if (IsSubclassOfRawGeneric(typeof(OptionalConstrainedValueParameter<>), parameter.GetType())) {
+        var x = (IEnumerable)parameter.GetType().GetProperty("ValidValues").GetValue(parameter, new object[] { });
+        return new ItemSet<IItem>(x.Cast<IItem>());
+      } else {
+        return new ItemSet<IItem>(ApplicationManager.Manager.GetInstances(valueDataType).Select(x => (IItem)x).OrderBy(x => x.ItemName));
+      }
+    }
+
+    private static bool IsSubclassOfRawGeneric(Type generic, Type toCheck) {
+      while (toCheck != typeof(object)) {
+        var cur = toCheck.IsGenericType ? toCheck.GetGenericTypeDefinition() : toCheck;
+        if (generic == cur) {
+          return true;
+        }
+        toCheck = toCheck.BaseType;
+      }
+      return false;
     }
 
@@ -167,5 +198,5 @@
     }
     public virtual string Description {
-      get { return parameter.Description; }
+      get { return base.ItemDescription; }
       set { throw new NotSupportedException(); }
     }
@@ -177,11 +208,14 @@
     }
     public override string ItemDescription {
-      get { return parameter != null ? parameter.Description : base.ItemDescription; }
+      //get { return parameter != null ? parameter.Description : base.ItemDescription; }
+      get { return base.ItemDescription; }
     }
     public override System.Drawing.Image ItemImage {
-      get { return parameter != null ? parameter.ItemImage : base.ItemImage; }
+      //get { return parameter != null ? parameter.ItemImage : base.ItemImage; }
+      get { return base.ItemImage; }
     }
     public override string ItemName {
-      get { return parameter != null ?parameter.ItemName : base.ItemName; }
+      //get { return parameter != null ?parameter.ItemName : base.ItemName; }
+      get { return base.ItemName; }
     }
     #endregion
@@ -235,31 +269,32 @@
     }
 
-    public void Parameterize() {
-      this.parameter.ActualValue = this.ActualValue.Value;
-    }
-
-    public void Randomize() {
-      if (Optimize) {
-        Random rand = new Random(); // todo: use global random
-        actualValueConfigurationIndex = rand.Next(ValueConfigurations.CheckedItems.Count());
-        this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).Randomize();
+    public void Parameterize(IValueParameter parameter) {
+      parameter.ActualValue = this.ActualValue.Value;
+    }
+
+    public void Randomize(IRandom random) {
+      if (Optimize) {
+        actualValueConfigurationIndex = random.Next(ValueConfigurations.CheckedItems.Count());
+        this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).Randomize(random);
         this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
       }
     }
 
-    public void Mutate() {
+    public void Mutate(IRandom random) {
       if (Optimize) {
         foreach (IValueConfiguration vc in this.ValueConfigurations.CheckedItems) {
-          vc.Mutate();
-        }
+          vc.Mutate(random);
+        }
+        actualValueConfigurationIndex = random.Next(ValueConfigurations.CheckedItems.Count());
         this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
-      }
-    }
-
-    public void Cross(IOptimizable other) {
+        this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).Mutate(random);
+      }
+    }
+
+    public void Cross(IOptimizable other, IRandom random) {
       if (Optimize) {
         IParameterConfiguration otherPc = (IParameterConfiguration)other;
         for (int i = 0; i < this.ValueConfigurations.Count; i++) {
-          this.ValueConfigurations.ElementAt(i).Cross(otherPc.ValueConfigurations.ElementAt(i));
+          this.ValueConfigurations.ElementAt(i).Cross(otherPc.ValueConfigurations.ElementAt(i), random);
         }
         this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/ConstrainedValue.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/ConstrainedValue.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/ConstrainedValue.cs	(revision 5009)
@@ -38,6 +38,9 @@
       this.value.ToStringChanged -= new EventHandler(value_ToStringChanged);
     }
-    
+
+    #region constructors and cloning
     public ConstrainedValue() { }
+    [StorableConstructor]
+    protected ConstrainedValue(bool deserializing) : base(deserializing) { }
     public ConstrainedValue(IItem value, Type valueDataType) {
       this.Value = value;
@@ -51,4 +54,9 @@
       return new ConstrainedValue(this, cloner);
     }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (this.value != null) RegisterEvents();
+    }
+    #endregion
 
     void value_ToStringChanged(object sender, EventArgs e) {
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/DoubleValueRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/DoubleValueRange.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/DoubleValueRange.cs	(revision 5009)
@@ -5,10 +5,15 @@
 using HeuristicLab.Data;
 using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
 
 namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
   public class DoubleValueRange : Range<DoubleValue> {
 
     public DoubleValueRange(DoubleValue lowerBound, DoubleValue upperBound, DoubleValue stepSize) : base(lowerBound, upperBound, stepSize) { }
     public DoubleValueRange() { }
+    [StorableConstructor]
+    protected DoubleValueRange(bool deserializing) : base(deserializing) { }
     protected DoubleValueRange(DoubleValueRange original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -16,9 +21,8 @@
     }
 
-    public override DoubleValue GetRandomValue() {
-      Random rand = new Random(); // todo: use common random
+    public override DoubleValue GetRandomValue(IRandom random) {
       double val;
       do {
-        val = Math.Round((rand.NextDouble() * (UpperBound.Value - LowerBound.Value) + LowerBound.Value) / StepSize.Value, 0) * StepSize.Value;
+        val = Math.Round((random.NextDouble() * (UpperBound.Value - LowerBound.Value) + LowerBound.Value) / StepSize.Value, 0) * StepSize.Value;
       } while (val < LowerBound.Value || val > UpperBound.Value);
       return new DoubleValue(val);
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/IntValueRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/IntValueRange.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/IntValueRange.cs	(revision 5009)
@@ -5,10 +5,15 @@
 using HeuristicLab.Data;
 using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
 
 namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
   public class IntValueRange : Range<IntValue> {
 
     public IntValueRange(IntValue lowerBound, IntValue upperBound, IntValue stepSize) : base(lowerBound, upperBound, stepSize) { }
     public IntValueRange() { }
+    [StorableConstructor]
+    protected IntValueRange(bool deserializing) : base(deserializing) { }
     protected IntValueRange(IntValueRange original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -16,9 +21,8 @@
     }
 
-    public override IntValue GetRandomValue() {
-      Random rand = new Random(); // todo: use common random
+    public override IntValue GetRandomValue(IRandom random) {
       int val;
       do {
-        val = rand.Next(LowerBound.Value / StepSize.Value, UpperBound.Value / StepSize.Value + 1) * StepSize.Value;
+        val = random.Next(LowerBound.Value / StepSize.Value, UpperBound.Value / StepSize.Value + 1) * StepSize.Value;
       } while (val < LowerBound.Value || val > UpperBound.Value);
       return new IntValue(val);
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/PercentValueRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/PercentValueRange.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/PercentValueRange.cs	(revision 5009)
@@ -5,10 +5,15 @@
 using HeuristicLab.Data;
 using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
 
 namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
   public class PercentValueRange : Range<PercentValue> {
 
     public PercentValueRange(PercentValue lowerBound, PercentValue upperBound, PercentValue stepSize) : base(lowerBound, upperBound, stepSize) { }
     public PercentValueRange() { }
+    [StorableConstructor]
+    protected PercentValueRange(bool deserializing) : base(deserializing) { }
     protected PercentValueRange(PercentValueRange original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -16,9 +21,8 @@
     }
 
-    public override PercentValue GetRandomValue() {
-      Random rand = new Random(); // todo: use common random
+    public override PercentValue GetRandomValue(IRandom random) {
       double val;
       do {
-        val = Math.Round((rand.NextDouble() * (UpperBound.Value - LowerBound.Value) + LowerBound.Value) / StepSize.Value, 0) * StepSize.Value;
+        val = Math.Round((random.NextDouble() * (UpperBound.Value - LowerBound.Value) + LowerBound.Value) / StepSize.Value, 0) * StepSize.Value;
       } while (val < LowerBound.Value || val > UpperBound.Value);
       return new PercentValue(val);
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/Range.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/Range.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/Range.cs	(revision 5009)
@@ -92,5 +92,4 @@
       this.StepSize = cloner.Clone(original.StepSize);
     }
-    #endregion
 
     [StorableHook(HookType.AfterDeserialization)]
@@ -106,4 +105,5 @@
       }
     }
+    #endregion
 
     #region Events
@@ -166,5 +166,5 @@
     }
     public bool Validate(string value, out string errorMessage) {
-      // TODO: check that upper is larger than lower
+      // TODO: check that upper is larger than lower and that stepsize < upper-lower
       T lower = (T)lowerBound.Clone();
       T upper = (T)upperBound.Clone();
@@ -191,16 +191,9 @@
     #endregion
 
+    public abstract T GetRandomValue(IRandom random);
 
-
-    public abstract T GetRandomValue();
-
-    #region IRange Members
-
-
-    IItem IRange.GetRandomValue() {
-      return GetRandomValue();
+    IItem IRange.GetRandomValue(IRandom random) {
+      return GetRandomValue(random);
     }
-
-    #endregion
   }
 }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/CheckedValueConfigurationCollection.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/CheckedValueConfigurationCollection.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/CheckedValueConfigurationCollection.cs	(revision 5009)
@@ -43,4 +43,8 @@
       return new CheckedValueConfigurationCollection(this, cloner);
     }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
 
     private void RegisterEvents() {
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/RootValueConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/RootValueConfiguration.cs	(revision 4997)
+++ 	(revision )
@@ -1,22 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  // todo: storable, name, descr, ...
-  public class RootValueConfiguration : ValueConfiguration {
-
-    public RootValueConfiguration(IItem value, Type valueDataType) : base(value, valueDataType) {
-      this.Optimize = true; // root must always be optimized
-    }
-    public RootValueConfiguration() { }
-    protected RootValueConfiguration(RootValueConfiguration original, Cloner cloner) : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RootValueConfiguration(this, cloner);
-    }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs	(revision 5009)
@@ -9,5 +9,7 @@
 namespace HeuristicLab.Problems.MetaOptimization {
   // TODO: ItemName/Descr, storability
+  [StorableClass]
   public class ValueConfiguration : Item, IValueConfiguration {
+    [Storable]
     protected bool isOptimizable;
     public bool IsOptimizable {
@@ -21,4 +23,5 @@
     }
 
+    [Storable]
     protected bool optimize;
     public bool Optimize {
@@ -39,4 +42,5 @@
     }
 
+    [Storable]
     protected IItemCollection<IParameterConfiguration> parameterConfigurations = new ItemCollection<IParameterConfiguration>();
     public IItemCollection<IParameterConfiguration> ParameterConfigurations {
@@ -45,4 +49,5 @@
     }
 
+    [Storable]
     protected ConstrainedValue actualValue;
     public ConstrainedValue ActualValue {
@@ -59,4 +64,5 @@
     }
 
+    [Storable]
     protected IRange rangeConstraint;
     public IRange RangeConstraint {
@@ -97,4 +103,8 @@
       return new ValueConfiguration(this, cloner);
     }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
     #endregion
 
@@ -181,39 +191,37 @@
       }
     }
-    
-    public void Parameterize() {
+
+    public void Parameterize(IParameterizedItem item) {
       foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
-        pc.Parameterize();
-      }
-    }
-
-    public void Randomize() {
+        pc.Parameterize((IValueParameter)item.Parameters[pc.ParameterName]);
+      }
+    }
+
+    public void Randomize(IRandom random) {
       if (Optimize) {
         if (rangeConstraint != null) {
-          this.actualValue.Value = rangeConstraint.GetRandomValue();
+          this.actualValue.Value = rangeConstraint.GetRandomValue(random);
         } else {
           foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
-            pc.Randomize();
-          }
-        }
-      }
-    }
-
-    public void Mutate() {
+            pc.Randomize(random);
+          }
+        }
+      }
+    }
+
+    public void Mutate(IRandom random) {
       if (Optimize) {
         if (rangeConstraint != null) {
-          Random rand = new Random(); // todo: use common random
-          // mutate every other value. todo: use some kind of mutation operator which is exchangable
-          if(rand.NextDouble() > 0.5)
-            this.actualValue.Value = rangeConstraint.GetRandomValue();
+          if (random.NextDouble() > 0.5)
+            this.actualValue.Value = rangeConstraint.GetRandomValue(random);
         } else {
           foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
-            pc.Mutate();
-          }
-        }
-      }
-    }
-
-    public void Cross(IOptimizable other) {
+            pc.Mutate(random);
+          }
+        }
+      }
+    }
+
+    public void Cross(IOptimizable other, IRandom random) {
       if (Optimize) {
         IValueConfiguration otherVc = (IValueConfiguration)other;
@@ -233,6 +241,5 @@
               this.actualValue.Value = new BoolValue(false);
             } else {
-              Random rand = new Random(); // todo: use common random
-              if(rand.NextDouble() > 0.5)
+              if (random.NextDouble() > 0.5)
                 this.actualValue.Value = new BoolValue(true);
               else
@@ -244,5 +251,5 @@
         } else {
           for (int i = 0; i < this.ParameterConfigurations.Count; i++) {
-            this.ParameterConfigurations.ElementAt(i).Cross(otherVc.ParameterConfigurations.ElementAt(i));
+            this.ParameterConfigurations.ElementAt(i).Cross(otherVc.ParameterConfigurations.ElementAt(i), random);
           }
         }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs	(revision 5009)
@@ -23,12 +23,12 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public ILookupParameter<IAlgorithm> AlgorithmParameter {
-      get { return (ILookupParameter<IAlgorithm>)Parameters["Algorithm"]; }
+    public ILookupParameter<EngineAlgorithm> AlgorithmParameter {
+      get { return (ILookupParameter<EngineAlgorithm>)Parameters["Algorithm"]; }
     }
-    public ILookupParameter<IItemList<IProblem>> ProblemsParameter {
-      get { return (ILookupParameter<IItemList<IProblem>>)Parameters["Problems"]; }
+    public ILookupParameter<IItemList<ISingleObjectiveProblem>> ProblemsParameter {
+      get { return (ILookupParameter<IItemList<ISingleObjectiveProblem>>)Parameters["Problems"]; }
     }
-    public ILookupParameter<IValueConfiguration> ParameterConfigurationParameter {
-      get { return (ILookupParameter<IValueConfiguration>)Parameters["ValueConfiguration"]; }
+    public ILookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
+      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
     }
     public ValueParameter<IntValue> RepetitionsParameter {
@@ -41,9 +41,10 @@
     }
 
-    public MetaOptimizationEvaluator() : base() {
+    public MetaOptimizationEvaluator()
+      : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the ParameterVector."));
-      Parameters.Add(new LookupParameter<IAlgorithm>("Algorithm", "Missing description."));
-      Parameters.Add(new LookupParameter<IItemList<IProblem>>("Problems", "Missing description."));
-      Parameters.Add(new LookupParameter<IValueConfiguration>("ValueConfiguration", "Missing description."));
+      Parameters.Add(new LookupParameter<EngineAlgorithm>("Algorithm", "Missing description."));
+      Parameters.Add(new LookupParameter<IItemList<ISingleObjectiveProblem>>("Problems", "Missing description."));
+      Parameters.Add(new LookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "Missing description."));
       Parameters.Add(new ValueParameter<IntValue>(RepetitionsParameterName, "Number of evaluations for one individual.", new IntValue(3)));
     }
@@ -60,24 +61,32 @@
 
     public override IOperation Apply() {
-      AlgorithmParameter.ActualValue.Prepare();
-      //ParameterizeAlgorithm();
-      //ParameterConfigurationParameter.ActualValue.Parameterize(AlgorithmParameter.ActualValue);
+      EngineAlgorithm algorithm = (EngineAlgorithm)ParameterConfigurationParameter.ActualValue.ActualValue.Value;
+
+      // set parameters
+      ParameterConfigurationParameter.ActualValue.Parameterize(algorithm);
+
       algorithmStopped = false;
-      AlgorithmParameter.ActualValue.Stopped += new EventHandler(ActualValue_Stopped);
+      algorithm.Stopped += new EventHandler(ActualValue_Stopped);
 
       double qualitySum = 0;
 
-      foreach (IProblem problem in ProblemsParameter.ActualValue) {
-        AlgorithmParameter.ActualValue.Problem = problem;
-        AlgorithmParameter.ActualValue.Start();
-        while (!algorithmStopped) {
-          Thread.Sleep(1000); // wait for algorithm to complete; do not rely on Algorithm.ExecutionState here, because change of ExecutionState happens before Run is added (which causes problems because Algorithm might get cloned when its started already)
-        }
-        AlgorithmParameter.ActualValue.Stopped -= new EventHandler(ActualValue_Stopped);
-        qualitySum += ((DoubleValue)AlgorithmParameter.ActualValue.Results["BestQuality"].Value).Value;
+      //foreach (ISingleObjectiveProblem problem in ProblemsParameter.ActualValue) {
+      algorithm.Engine = new SequentialEngine.SequentialEngine();
+      //algorithm.Problem = problem;
+      algorithm.Prepare();
+      algorithm.Start();
+      while (!algorithmStopped) {
+        Thread.Sleep(1000); // wait for algorithm to complete; do not rely on Algorithm.ExecutionState here, because change of ExecutionState happens before Run is added (which causes problems because Algorithm might get cloned when its started already)
       }
+      double quality = ((DoubleValue)algorithm.Results["BestQuality"].Value).Value;
+      ParameterConfigurationParameter.ActualValue.Quality.Value = quality;
+      qualitySum += quality;
+      //}
 
-      double qualityAvg = qualitySum / ProblemsParameter.ActualValue.Count;
-      this.QualityParameter.ActualValue = new DoubleValue(qualityAvg);
+      algorithm.Stopped -= new EventHandler(ActualValue_Stopped);
+
+      //double qualityAvg = qualitySum / ProblemsParameter.ActualValue.Count;
+      //this.QualityParameter.ActualValue = new DoubleValue(qualityAvg);
+      this.QualityParameter.ActualValue = new DoubleValue(quality);
 
       return base.Apply();
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj	(revision 5009)
@@ -78,4 +78,7 @@
       <HintPath>..\..\..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
     </Reference>
+    <Reference Include="HeuristicLab.SequentialEngine-3.3">
+      <HintPath>..\..\HeuristicLab.MetaOptimization.Test\bin\Debug\HeuristicLab.SequentialEngine-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -96,5 +99,5 @@
     <Compile Include="Encodings\RangeConstraints\DoubleValueRange.cs" />
     <Compile Include="Encodings\RangeConstraints\IntValueRange.cs" />
-    <Compile Include="Encodings\ValueConfigurations\RootValueConfiguration.cs" />
+    <Compile Include="Encodings\ParameterConfigurationTree.cs" />
     <Compile Include="Encodings\ValueConfigurations\ValueConfiguration.cs" />
     <Compile Include="Encodings\ValueConfigurations\CheckedValueConfigurationCollection.cs" />
@@ -112,4 +115,6 @@
     <Compile Include="Interfaces\IValueConfiguration.cs" />
     <Compile Include="Encodings\RangeConstraints\Range.cs" />
+    <Compile Include="Interfaces\IParameterConfigurationManipulator.cs" />
+    <Compile Include="Manipulators\ParameterConfigurationManipulator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="MetaOptimizationProblem.cs" />
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs	(revision 5009)
@@ -12,8 +12,7 @@
     ConstrainedValue ActualValue { get; set; }
 
-    void Parameterize();
-    void Randomize();
-    void Mutate();
-    void Cross(IOptimizable other);
+    void Randomize(IRandom random);
+    void Mutate(IRandom random);
+    void Cross(IOptimizable other, IRandom random);
 
     event EventHandler IsOptimizableChanged;
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfiguration.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfiguration.cs	(revision 5009)
@@ -10,5 +10,7 @@
     Type ParameterDataType { get; }
     ICheckedValueConfigurationCollection ValueConfigurations { get; }
-    IEnumerable<IItem> ValidValues { get; }
+    IItemSet<IItem> ValidValues { get; }
+
+    void Parameterize(IValueParameter parameter);
   }
 }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationManipulator.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationManipulator.cs	(revision 5009)
@@ -0,0 +1,12 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Optimization;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  public interface IParameterConfigurationManipulator : IParameterConfigurationOperator, IManipulator {
+    ILookupParameter<ParameterConfigurationTree> ParameterConfigurationTreeParameter { get; }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IRange.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IRange.cs	(revision 5009)
@@ -14,5 +14,5 @@
     event EventHandler StepSizeChanged;
 
-    IItem GetRandomValue();
+    IItem GetRandomValue(IRandom random);
   }
 
@@ -21,5 +21,5 @@
     new T UpperBound { get; set; }
     new T StepSize { get; set; }
-    new T GetRandomValue();
+    new T GetRandomValue(IRandom random);
   }
 }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IValueConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IValueConfiguration.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IValueConfiguration.cs	(revision 5009)
@@ -9,4 +9,5 @@
     event EventHandler ValueChanged;
 
+    void Parameterize(IParameterizedItem item);
   }
 }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Manipulators/ParameterConfigurationManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Manipulators/ParameterConfigurationManipulator.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Manipulators/ParameterConfigurationManipulator.cs	(revision 5009)
@@ -0,0 +1,44 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  // todo: item name/descr...
+  [StorableClass]
+  public class ParameterConfigurationManipulator : SingleSuccessorOperator, IParameterConfigurationManipulator, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ParameterConfigurationTree> ParameterConfigurationTreeParameter {
+      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
+    }
+
+    public ParameterConfigurationManipulator() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "The parameter configuration which should be manipulated."));
+    }
+    [StorableConstructor]
+    protected ParameterConfigurationManipulator(bool deserializing) : base(deserializing) { }
+    protected ParameterConfigurationManipulator(ParameterConfigurationManipulator original, Cloner cloner) : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterConfigurationManipulator(this, cloner);
+    }
+
+    public sealed override IOperation Apply() {
+      ParameterConfigurationTreeParameter.ActualValue.Mutate(RandomParameter.ActualValue);
+      return base.Apply();
+    }
+
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 4997)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 5009)
@@ -37,16 +37,16 @@
     private const string AlgorithmParameterName = "Algorithm";
     private const string ProblemsParameterName = "Problems";
-    private const string AlgorithmParameterConfigurationParameterName = "AlgorithmParameterConfiguration";
-    private const string ProblemParametersConfigurationParameterName = "ProblemParametersConfiguration";
+    private const string AlgorithmParameterConfigurationParameterName = "InitialParameterConfigurationTree";
+    //private const string ProblemParametersConfigurationParameterName = "ProblemParametersConfiguration";
 
     #region Parameter Properties
-    public ValueParameter<IAlgorithm> AlgorithmParameter {
-      get { return (ValueParameter<IAlgorithm>)Parameters[AlgorithmParameterName]; }
+    public IValueParameter<EngineAlgorithm> AlgorithmParameter {
+      get { return (ValueParameter<EngineAlgorithm>)Parameters[AlgorithmParameterName]; }
     }
-    public ValueParameter<IItemList<ISingleObjectiveProblem>> ProblemsParameter {
+    public IValueParameter<IItemList<ISingleObjectiveProblem>> ProblemsParameter {
       get { return (ValueParameter<IItemList<ISingleObjectiveProblem>>)Parameters[ProblemsParameterName]; }
     }
-    public ValueParameter<IValueConfiguration> AlgorithmParameterConfigurationParameter {
-      get { return (ValueParameter<IValueConfiguration>)Parameters[AlgorithmParameterConfigurationParameterName]; }
+    public IValueParameter<ParameterConfigurationTree> AlgorithmParameterConfigurationParameter {
+      get { return (ValueParameter<ParameterConfigurationTree>)Parameters[AlgorithmParameterConfigurationParameterName]; }
     }
     //public ValueParameter<IItemList<IParameterConfiguration>> ProblemParametersConfigurationParameter {
@@ -56,5 +56,5 @@
 
     #region Properties
-    public IAlgorithm Algorithm {
+    public EngineAlgorithm Algorithm {
       get { return AlgorithmParameter.Value; }
       set { AlgorithmParameter.Value = value; }
@@ -64,5 +64,5 @@
       set { ProblemsParameter.Value = value; }
     }
-    public IValueConfiguration AlgorithmParameterConfiguration {
+    public ParameterConfigurationTree AlgorithmParameterConfiguration {
       get { return AlgorithmParameterConfigurationParameter.Value; }
       set { AlgorithmParameterConfigurationParameter.Value = value; }
@@ -74,9 +74,8 @@
     #endregion
 
-    public MetaOptimizationProblem()
-      : base() {
-      Parameters.Add(new ValueParameter<IAlgorithm>(AlgorithmParameterName, "The algorithm which's parameters should be optimized."));
-      Parameters.Add(new ValueParameter<IItemList<IProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ItemList<IProblem>()));
-      Parameters.Add(new ValueParameter<IValueConfiguration>(AlgorithmParameterConfigurationParameterName, "List of algorithm parameters that should be optimized."));
+    public MetaOptimizationProblem() : base() {
+      Parameters.Add(new ValueParameter<EngineAlgorithm>(AlgorithmParameterName, "The algorithm which's parameters should be optimized."));
+      Parameters.Add(new ValueParameter<IItemList<ISingleObjectiveProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ItemList<ISingleObjectiveProblem>()));
+      Parameters.Add(new ValueParameter<ParameterConfigurationTree>(AlgorithmParameterConfigurationParameterName, "List of algorithm parameters that should be optimized."));
       //Parameters.Add(new ValueParameter<IItemList<IParameterConfiguration>>(ProblemParametersConfigurationParameterName, "List of problem parameters that should be optimized.", new ItemList<IParameterConfiguration>()));
       
@@ -122,5 +121,5 @@
     }
     private void ParameterizeEvaluator() {
-      ((MetaOptimizationEvaluator)Evaluator).ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ValueConfigurationParameter.ActualName;
+      ((MetaOptimizationEvaluator)Evaluator).ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
     }
     private void ParameterizeAnalyzer() {
@@ -152,16 +151,12 @@
     }
     void BaseLevelAlgorithmParameter_ValueChanged(object sender, EventArgs e) {
-      if (Algorithm != null) {
-        Algorithm.ProblemChanged += new EventHandler(BaseLevelAlgorithm_ProblemChanged);
-        AlgorithmParameterConfiguration = new RootValueConfiguration(Algorithm, Algorithm.GetType());
-      }
+      Algorithm.ProblemChanged += new EventHandler(BaseLevelAlgorithm_ProblemChanged); // when to deregister?
       BaseLevelAlgorithm_ProblemChanged(sender, e);
     }
 
     void BaseLevelAlgorithm_ProblemChanged(object sender, EventArgs e) {
-      //ClearProblemParameters();
-      //if (Algorithm.Problem != null) {
-      //  AddProblemParameters();
-      //}
+      if (Algorithm != null && Algorithm.Problem != null) {
+        AlgorithmParameterConfiguration = new ParameterConfigurationTree(Algorithm);
+      }
     }
     #endregion
