Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestQualityAnalyzer.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestQualityAnalyzer.cs	(revision 4539)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestQualityAnalyzer.cs	(revision 4830)
@@ -9,4 +9,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Data;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -16,14 +17,15 @@
   [Item("BestQualityAnalyzer", "TODO An operator for analyzing the best solution of Traveling Salesman Problems given in path representation using city coordinates.")]
   [StorableClass]
-  public sealed class BestQualityAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  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<IParameterSet> ParameterSetParameter {
-      get { return (ScopeTreeLookupParameter<IParameterSet>)Parameters["ParameterSet"]; }
+    public ScopeTreeLookupParameter<IParameterConfiguration> ParameterVectorParameter {
+      get { return (ScopeTreeLookupParameter<IParameterConfiguration>)Parameters["ParameterConfiguration"]; }
     }
     public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
       get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public LookupParameter<IParameterSet> BestSolutionParameter {
-      get { return (LookupParameter<IParameterSet>)Parameters["BestSolution"]; }
+    public LookupParameter<IParameterConfiguration> BestSolutionParameter {
+      get { return (LookupParameter<IParameterConfiguration>)Parameters["BestSolution"]; }
     }
     public ValueLookupParameter<ResultCollection> ResultsParameter {
@@ -33,16 +35,23 @@
       get { return (LookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
     }
-    public LookupParameter<IParameterSet> BestKnownSolutionParameter {
-      get { return (LookupParameter<IParameterSet>)Parameters["BestKnownSolution"]; }
+    public LookupParameter<IParameterConfiguration> BestKnownSolutionParameter {
+      get { return (LookupParameter<IParameterConfiguration>)Parameters["BestKnownSolution"]; }
     }
 
-    public BestQualityAnalyzer()
+    public BestParameterConfigurationAnalyzer()
       : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<IParameterSet>("ParameterSet", "TODO The TSP solutions given in path representation from which the best solution should be analyzed."));
+      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<DoubleValue>("Quality", "TODO The qualities of the TSP solutions which should be analyzed."));
-      Parameters.Add(new LookupParameter<IParameterSet>("BestSolution", "TODO The best TSP solution."));
+      Parameters.Add(new LookupParameter<IParameterConfiguration>("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<IParameterSet>("BestKnownSolution", "TODO The best known solution of this TSP instance."));
+      Parameters.Add(new LookupParameter<IParameterConfiguration>("BestKnownSolution", "TODO The best known solution of this TSP instance."));
+    }
+
+    [StorableConstructor]
+    private BestParameterConfigurationAnalyzer(bool deserializing) : base(deserializing) { }
+    private BestParameterConfigurationAnalyzer(BestParameterConfigurationAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BestParameterConfigurationAnalyzer(this, cloner);
     }
 
@@ -51,5 +60,5 @@
       ResultCollection results = ResultsParameter.ActualValue;
       DoubleValue bestKnownQuality = BestKnownQualityParameter.ActualValue;
-      ItemArray<IParameterSet> parameterSets = ParameterSetParameter.ActualValue;
+      ItemArray<IParameterConfiguration> parameterVectors = ParameterVectorParameter.ActualValue;
 
       int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
@@ -57,5 +66,5 @@
       if (bestKnownQuality == null || qualities[i].Value < bestKnownQuality.Value) {
         BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[i].Value);
-        BestKnownSolutionParameter.ActualValue = (IParameterSet)parameterSets[i].Clone();
+        BestKnownSolutionParameter.ActualValue = (IParameterConfiguration)parameterVectors[i].Clone();
       }
 
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Creators/RandomParameterConfigurationCreator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Creators/RandomParameterConfigurationCreator.cs	(revision 4830)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Creators/RandomParameterConfigurationCreator.cs	(revision 4830)
@@ -0,0 +1,52 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  /// <summary>
+  /// An operator which creates a new random permutation of integer values.
+  /// </summary>
+  [Item("RandomParameterVectorCreator", "An operator which creates a new set of parameters TODO.")]
+  [StorableClass]
+  public sealed class RandomParameterConfigurationCreator : SingleSuccessorOperator, IStochasticOperator, IParameterConfigurationCreator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<IParameterConfiguration> ParameterConfigurationParameter {
+      get { return (ILookupParameter<IParameterConfiguration>)Parameters["ParameterConfiguration"]; }
+    }
+
+    public ILookupParameter<IParameterConfiguration> NewParameterConfigurationParameter {
+      get { return (ILookupParameter<IParameterConfiguration>)Parameters["NewParameterConfiguration"]; }
+    }
+
+    [StorableConstructor]
+    private RandomParameterConfigurationCreator(bool deserializing) : base(deserializing) { }
+    private RandomParameterConfigurationCreator(RandomParameterConfigurationCreator original, Cloner cloner) : base(original, cloner) { }
+    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<IParameterConfiguration>("ParameterConfiguration", "The new random parameter set."));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RandomParameterConfigurationCreator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      NewParameterConfigurationParameter.ActualValue = (IParameterConfiguration)ParameterConfigurationParameter.ActualValue.Clone();
+      //NewParameterConfigurationParameter.ActualValue.Randomize();
+      return base.Apply();
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Creators/RandomParameterSetCreator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Creators/RandomParameterSetCreator.cs	(revision 4539)
+++ 	(revision )
@@ -1,55 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  /// <summary>
-  /// An operator which creates a new random permutation of integer values.
-  /// </summary>
-  [Item("RandomParameterSetCreator", "An operator which creates a new set of parameters TODO.")]
-  [StorableClass]
-  public sealed class RandomParameterSetCreator : SingleSuccessorOperator, IParameterSetCreator {
-    public override bool CanChangeName {
-      get { return false; }
-    }
-
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<IParameterSet> ParameterSetParameter {
-      get { return (ILookupParameter<IParameterSet>)Parameters["ParameterSet"]; }
-    }
-
-    [Storable]
-    private ParameterConfigurationList parametersToOptimize;
-    public ParameterConfigurationList ParametersToOptimize {
-      get { return parametersToOptimize; }
-      set { parametersToOptimize = value; }
-    }
-
-    public RandomParameterSetCreator()
-      : 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<IParameterSet>("ParameterSet", "The new random parameter set."));
-    }
-
-    public override IOperation Apply() {
-      ParameterSetParameter.ActualValue = new ParameterSet(ParametersToOptimize, RandomParameter.ActualValue);
-      return base.Apply();
-    }
-
-    #region Cloning
-    public override IDeepCloneable Clone(Cloner cloner) {
-      RandomParameterSetCreator clone = (RandomParameterSetCreator) base.Clone(cloner);
-      clone.parametersToOptimize = (ParameterConfigurationList)this.parametersToOptimize.Clone();
-      return clone;
-    }
-    #endregion
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/BooleanParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/BooleanParameterConfiguration.cs	(revision 4539)
+++ 	(revision )
@@ -1,9 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  public class BooleanParameterConfiguration {
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/Crossovers/ParameterSetCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/Crossovers/ParameterSetCrossover.cs	(revision 4539)
+++ 	(revision )
@@ -1,88 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Encodings.BinaryVectorEncoding;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Collections;
-using HeuristicLab.Data;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.MetaOptimization.Encodings.Crossovers {
-  /// <summary>
-  /// 
-  /// </summary>
-  [Item("ParameterSetCrossover", "TODO")]
-  [StorableClass]
-  public class ParameterSetCrossover : SingleSuccessorOperator, IParameterSetOperator, ICrossover {
-    public override bool CanChangeName {
-      get { return false; }
-    }
-
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<ItemArray<IParameterSet>> ParentsParameter {
-      get { return (ScopeTreeLookupParameter<IParameterSet>)Parameters["Parents"]; }
-    }
-    public ILookupParameter<IParameterSet> ChildParameter {
-      get { return (ILookupParameter<IParameterSet>)Parameters["Child"]; }
-    }
-
-    public IValueParameter<IBinaryVectorCrossover> BinaryVectorCrossoverParameter {
-      get { return (IValueParameter<IBinaryVectorCrossover>)Parameters["BinaryVectorCrossover"]; }
-    }
-    public IValueParameter<IIntegerVectorCrossover> IntegerVectorCrossoverParameter {
-      get { return (IValueParameter<IIntegerVectorCrossover>)Parameters["IntegerVectorCrossover"]; }
-    }
-    public IValueParameter<IRealVectorCrossover> RealVectorCrossoverParameter {
-      get { return (IValueParameter<IRealVectorCrossover>)Parameters["RealVectorCrossover"]; }
-    }
-    public ParameterSetCrossover()
-      : base() {
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
-      Parameters.Add(new ScopeTreeLookupParameter<IParameterSet>("Parents", "The parent vectors which should be crossed."));
-      ParentsParameter.ActualName = "ParameterSet";
-      Parameters.Add(new LookupParameter<IParameterSet>("Child", "The child vector resulting from the crossover."));
-      ChildParameter.ActualName = "ParameterSet";
-      Parameters.Add(new ValueParameter<IRealVectorCrossover>("BinaryVectorCrossover", "Crossover operator used for crossing binary parameters"));
-      Parameters.Add(new ValueParameter<IRealVectorCrossover>("IntegerVectorCrossover", "Crossover operator used for crossing integer parameters"));
-      Parameters.Add(new ValueParameter<IRealVectorCrossover>("RealVectorCrossover", "Crossover operator used for crossing real parameters"));
-    }
-    public override IOperation Apply() {
-      IEnumerable<IndexedItem<IParameterConfiguration>> integerParameters1 = GetIntegerParameters(ParentsParameter.ActualValue[0]);
-      IEnumerable<IndexedItem<IParameterConfiguration>> integerParameters2 = GetIntegerParameters(ParentsParameter.ActualValue[1]);
-      IParameterSet child = (IParameterSet)ParentsParameter.ActualValue[0].Clone();
-      
-      // TODO: use specific crossover operators to do the crossing
-      // for now: just swap the int-values
-      foreach (var par in integerParameters1) {
-        ParentsParameter.ActualValue[1].Parameters.ElementAt(par.Index).Parameter.ActualValue = par.Value.Parameter.ActualValue;
-      }
-      foreach (var par in integerParameters2) {
-        ParentsParameter.ActualValue[0].Parameters.ElementAt(par.Index).Parameter.ActualValue = par.Value.Parameter.ActualValue;
-      }
-
-      ChildParameter.ActualValue = child;
-      return base.Apply();
-    }
-
-    private IEnumerable<IndexedItem<IParameterConfiguration>> GetIntegerParameters(IParameterSet parameterSet) {
-      List<IndexedItem<IParameterConfiguration>> integerParameters = new List<IndexedItem<IParameterConfiguration>>();
-      int i = 0;
-      foreach (var item in parameterSet.Parameters) {
-        if (item.Parameter.DataType == typeof(IntValue)) {
-          integerParameters.Add(new IndexedItem<IParameterConfiguration>(i, (IParameterConfiguration)item.Clone()));
-        }
-        i++;
-      }
-      return integerParameters;
-    }
-
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/Crossovers/ParameterVectorCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/Crossovers/ParameterVectorCrossover.cs	(revision 4830)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/Crossovers/ParameterVectorCrossover.cs	(revision 4830)
@@ -0,0 +1,87 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Collections;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.MetaOptimization.Encodings.Crossovers {
+  /// <summary>
+  /// 
+  /// </summary>
+  [Item("ParameterVectorCrossover", "TODO")]
+  [StorableClass]
+  public class ParameterVectorCrossover : SingleSuccessorOperator, IParameterConfigurationOperator, ICrossover {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<IParameterConfiguration>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<IParameterConfiguration>)Parameters["Parents"]; }
+    }
+    public ILookupParameter<IParameterConfiguration> ChildParameter {
+      get { return (ILookupParameter<IParameterConfiguration>)Parameters["Child"]; }
+    }
+
+    private IIntegerVectorCrossover integerVectorCrossover;
+    public IIntegerVectorCrossover IntegerVectorCrossover {
+      get { return integerVectorCrossover; }
+      set { integerVectorCrossover = value; }
+    }
+    private IRealVectorCrossover realVectorCrossover;
+    public IRealVectorCrossover RealVectorCrossover {
+      get { return realVectorCrossover; }
+      set { realVectorCrossover = value; }
+    }
+
+    [StorableConstructor]
+    protected ParameterVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected ParameterVectorCrossover(ParameterVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    public ParameterVectorCrossover()
+      : 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";
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterVectorCrossover(this, cloner);
+    }
+
+    public override IOperation Apply() {
+
+      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;
+      return base.Apply();
+    }
+
+    private IntValue CrossInteger(IParameterConfiguration parameter1, IParameterConfiguration parameter2) {
+      IntegerVector integerChild = HeuristicLab.Encodings.IntegerVectorEncoding.DiscreteCrossover.Apply(
+        RandomParameter.ActualValue,
+        new IntegerVector(new IntArray(new int[] { ((IntValue)parameter1.Parameter.ActualValue).Value })),
+        new IntegerVector(new IntArray(new int[] { ((IntValue)parameter2.Parameter.ActualValue).Value })));
+      return new IntValue(integerChild[0]);
+    }
+
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/EnumerableParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/EnumerableParameterConfiguration.cs	(revision 4539)
+++ 	(revision )
@@ -1,9 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  public class EnumerableParameterConfiguration {
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/IntValueParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/IntValueParameterConfiguration.cs	(revision 4830)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/IntValueParameterConfiguration.cs	(revision 4830)
@@ -0,0 +1,25 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class IntValueParameterConfiguration : ValueTypeParameterConfiguration<IntValue> {
+
+    public IntValueParameterConfiguration(ParameterConfiguration parentConfiguration, string parameterName, IItem value) : base(parentConfiguration, parameterName, value) {
+    }
+
+    protected IntValueParameterConfiguration() { }
+    [StorableConstructor]
+    protected IntValueParameterConfiguration(bool deserializing) : base(deserializing) { }
+    protected IntValueParameterConfiguration(IntValueParameterConfiguration original, Cloner cloner) : base(original, cloner) {    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntValueParameterConfiguration(this, cloner);
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/NumericParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/NumericParameterConfiguration.cs	(revision 4539)
+++ 	(revision )
@@ -1,91 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Data;
-using HeuristicLab.Core;
-using HeuristicLab.Collections;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class NumericParameterConfiguration : ParameterConfiguration {
-    [Storable]
-    private NumericRangeList ranges;
-    public NumericRangeList Ranges {
-      get { return ranges; }
-    }
-
-    protected NumericParameterConfiguration() { }
-    
-    [StorableConstructor]
-    protected NumericParameterConfiguration(bool deserializing) : base(deserializing) { }
-
-    public NumericParameterConfiguration(IParameter parameter, string category)
-      : base(parameter, category) {
-      this.ranges = new NumericRangeList();
-      this.ranges.ItemsAdded += new CollectionItemsChangedEventHandler<INumericRange>(ranges_ItemsAdded);
-      this.ranges.ItemsRemoved += new CollectionItemsChangedEventHandler<INumericRange>(ranges_ItemsRemoved);
-      this.ranges.CollectionReset += new CollectionItemsChangedEventHandler<INumericRange>(ranges_CollectionReset);
-    }
-
-
-
-    void ranges_CollectionReset(object sender, CollectionItemsChangedEventArgs<INumericRange> e) {
-      foreach (var i in e.Items) {
-        DeregisterItemEvents(i);
-      }
-      OnToStringChanged();
-    }
-
-    void ranges_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<INumericRange> e) {
-      foreach (var i in e.Items) {
-        DeregisterItemEvents(i);
-      }
-      OnToStringChanged();
-    }
-
-    void ranges_ItemsAdded(object sender, CollectionItemsChangedEventArgs<INumericRange> e) {
-      foreach (var i in e.Items) {
-        RegisterItemEvents(i);
-      }
-      OnToStringChanged();
-    }
-
-    private void DeregisterItemEvents(INumericRange range) {
-      range.ToStringChanged -= new EventHandler(range_ToStringChanged);
-    }
-    private void RegisterItemEvents(INumericRange range) {
-      range.ToStringChanged += new EventHandler(range_ToStringChanged);
-    }
-
-    public IntValue GetRandomValue() {
-      return new IntValue(0);
-    }
-
-    #region Cloning
-    public override Common.IDeepCloneable Clone(Common.Cloner cloner) {
-      NumericParameterConfiguration clone = (NumericParameterConfiguration)base.Clone(cloner);
-      clone.ranges = new NumericRangeList();
-      foreach (INumericRange range in this.ranges) {
-        clone.ranges.Add(range);
-      }
-      return clone;
-    }
-    #endregion
-
-    void range_ToStringChanged(object sender, EventArgs e) {
-      OnToStringChanged();
-    }
-
-    public override string ToString() {
-      return string.Format("{0}: ({1})", base.ToString(), string.Join(",", ranges.Select(r => r.ToString()).ToArray()));
-    }
-
-    public override void SetParameterWithRandomValue(IRandom random) {
-      int rangeIndex = random.Next(ranges.Count);
-      int value = random.Next(ranges.ElementAt(rangeIndex).LowerBound.Value, ranges.ElementAt(rangeIndex).UpperBound.Value); // TODO: respect StepSize parameter
-      this.Parameter.ActualValue = new IntValue(value);
-    }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfiguration.cs	(revision 4539)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfiguration.cs	(revision 4830)
@@ -6,94 +6,204 @@
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Problems.MetaOptimization {
   [StorableClass]
-  public abstract class ParameterConfiguration : IParameterConfiguration {
-    [Storable]
-    public IParameter Parameter { get; set; }
-
-    [Storable]
-    public string Category { get; set; }
+  public class ParameterConfiguration : DeepCloneable, IParameterConfiguration, IStorableContent {
+    protected ParameterConfiguration parentConfiguration;
+
+    [Storable]
+    public string Filename { get; set; }
+
+    [Storable]
+    protected bool optimizationEnabled;
+    public bool OptimizationEnabled {
+      get { return optimizationEnabled; }
+      set {
+        if (optimizationEnabled != value) {
+          optimizationEnabled = value;
+          OnOptimizationEnabledChanged();
+        }
+      }
+    }
+
+    [Storable]
+    protected string parameterName;
+    public string ParameterName {
+      get { return parameterName; }
+      set {
+        if (parameterName != value) {
+          parameterName = value;
+        }
+      }
+    }
+
+    [Storable]
+    protected IItemList<IParameterConfiguration> childParameterConfigurations = new ItemList<IParameterConfiguration>();
+    public IItemList<IParameterConfiguration> ChildParameterConfigurations {
+      get { return childParameterConfigurations; }
+    }
+
+    public virtual IParameter Parameter {
+      get {
+        return parentConfiguration.GetChildParameter(this.parameterName);
+      }
+    }
+
+    protected IItem value;
+    public IItem Value {
+      get { return value; }
+      set {
+        if (this.value != value) {
+          ClearChildParameterConfigurations();
+          OnValueChanging();
+          this.value = value;
+          if(this.value is IParameterizedNamedItem) AddChildParameterConfigurations(this.value as IParameterizedNamedItem);
+          OnValueChanged();
+        }
+      }
+    }
+
+    public ParameterConfiguration(ParameterConfiguration parentConfiguration, string parameterName, IItem value) {
+      this.parentConfiguration = parentConfiguration;
+      this.ParameterName = parameterName;
+      this.Value = value;
+    }
 
     public ParameterConfiguration() { }
-    
     [StorableConstructor]
     protected ParameterConfiguration(bool deserializing) { }
-
-    public ParameterConfiguration(IParameter parameter, string category) {
-      this.Parameter = parameter;
-      this.Category = category;
-      Parameter.NameChanged += this.NameChanged;
-      Parameter.NameChanging += this.NameChanging;
-      Parameter.DescriptionChanged += this.DescriptionChanged;
-      Parameter.ItemImageChanged += this.ItemImageChanged;
-      parameter.ToStringChanged += this.ToStringChanged;
-    }
-
-    public bool CanChangeDescription {
-      get { return false; }
-    }
-
-    public bool CanChangeName {
-      get { return false; }
-    }
-
-    public string Description {
+    protected ParameterConfiguration(ParameterConfiguration original, Cloner cloner)
+      : base(original, cloner) {
+      this.OptimizationEnabled = original.optimizationEnabled;
+      this.ParameterName = original.parameterName;
+      this.Value = cloner.Clone(original.Value);
+      this.childParameterConfigurations = cloner.Clone(original.childParameterConfigurations);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterConfiguration(this, cloner);
+    }
+
+    protected virtual IValueParameter GetChildParameter(string childParameterName) {
+      return (IValueParameter)((IParameterizedItem)Value).Parameters[childParameterName];
+    }
+
+    protected virtual void AddChildParameterConfigurations(IParameterizedNamedItem parameterizedItem) {
+      foreach (var childParameter in parameterizedItem.Parameters) {
+        var pc = ParameterConfiguration.Create(this, parameterizedItem, childParameter);
+        if (pc != null) this.childParameterConfigurations.Add(pc);
+      }
+    }
+    protected virtual void ClearChildParameterConfigurations() {
+      childParameterConfigurations.Clear();
+    }
+
+    #region INamedItem Properties
+    public virtual string Name {
+      get { return Parameter.Name; }
+      set { throw new NotSupportedException(); }
+    }
+    public virtual string Description {
       get { return Parameter.Description; }
       set { throw new NotSupportedException(); }
     }
-    public string Name {
-      get { return Parameter.Name; }
-      set { throw new NotSupportedException(); }
-    }
-
-    public string ItemDescription {
+    public virtual bool CanChangeDescription {
+      get { return false; }
+    }
+    public virtual bool CanChangeName {
+      get { return false; }
+    }
+    public virtual string ItemDescription {
       get { return Parameter.ItemDescription; }
     }
-
-    public System.Drawing.Image ItemImage {
+    public virtual System.Drawing.Image ItemImage {
       get { return Parameter.ItemImage; }
     }
-
-    public string ItemName {
+    public virtual string ItemName {
       get { return Parameter.ItemName; }
     }
-
-    public Version ItemVersion {
+    public virtual Version ItemVersion {
       get { return Parameter.ItemVersion; }
     }
+    #endregion
 
     #region Events
     public virtual event EventHandler NameChanged;
+    protected virtual void OnNameChanged(object sender, EventArgs e) {
+      var handler = NameChanged;
+      if (handler != null) handler(sender, e);
+    }
+
     public virtual event EventHandler<CancelEventArgs<string>> NameChanging;
+    protected virtual void OnNameChanging(object sender, CancelEventArgs<string> e) {
+      var handler = NameChanging;
+      if (handler != null) handler(sender, e);
+    }
+
     public virtual event EventHandler DescriptionChanged;
+    protected virtual void OnDescriptionChanged(object sender, EventArgs e) {
+      var handler = DescriptionChanged;
+      if (handler != null) handler(sender, e);
+    }
+
     public virtual event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged(object sender, EventArgs e) {
+      var handler = ItemImageChanged;
+      if (handler != null) handler(sender, e);
+    }
+
     public virtual event EventHandler ToStringChanged;
-
-    protected virtual void OnToStringChanged() {
+    protected virtual void OnStringChanged(object sender, EventArgs e) {
       var handler = ToStringChanged;
+      if (handler != null) handler(this, e); // important to set 'this' as sender
+    }
+
+    public virtual event EventHandler OptimizationEnabledChanged;
+    protected virtual void OnOptimizationEnabledChanged() {
+      var handler = OptimizationEnabledChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }
+
+    public virtual event EventHandler ValueChanging;
+    protected virtual void OnValueChanging() {
+      var handler = ValueChanging;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public virtual event EventHandler ValueChanged;
+    protected virtual void OnValueChanged() {
+      var handler = ValueChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
     #endregion
 
-    #region Cloning
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      ParameterConfiguration clone = (ParameterConfiguration)Activator.CreateInstance(this.GetType(), true);
-      cloner.RegisterClonedObject(this, clone);
-      clone.Parameter = (IParameter)cloner.Clone(this.Parameter);
-      clone.Category = this.Category;
-      return clone;
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-    #endregion
-
     public override string ToString() {
-      return string.Format("{0}.{1}", Category, Parameter.Name);
-    }
-    
-    public abstract void SetParameterWithRandomValue(IRandom random);
+      return string.Format("{0} ({1})", ParameterName, Value);
+    }
+
+    public static IParameterConfiguration Create(IParameterizedNamedItem parent) {
+      return new RootParameterConfiguration(parent);
+    }
+
+    public static IParameterConfiguration Create(ParameterConfiguration parentConfiguration, IParameterizedNamedItem parent, IParameter parameter) {
+      if (parameter is IValueParameter) {
+        IValueParameter valueParameter = parameter as IValueParameter;
+
+        if (typeof(IntValue).IsAssignableFrom(parameter.DataType)) {
+          return new IntValueParameterConfiguration(parentConfiguration, parameter.Name, valueParameter.Value);
+        } else if (typeof(IParameterizedItem).IsAssignableFrom(parameter.DataType)) {
+          return new ParameterConfiguration(parentConfiguration, parameter.Name, valueParameter.Value);
+        } else {
+          // todo
+          return new IntValueParameterConfiguration(parentConfiguration, parameter.Name, valueParameter.Value);
+        }
+      }
+      return null;
+    }
+
+    public void Parameterize(IParameterizedItem parameterizedItem) {
+      throw new NotImplementedException();
+    }
 
   }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationList.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationList.cs	(revision 4539)
+++ 	(revision )
@@ -1,18 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  [Item("ParameterOptimizationInfoList", "Represents a list of parameter configurations.")]
-  public class ParameterConfigurationList : CheckedItemCollection<IParameterConfiguration> {
-    public ParameterConfigurationList() : base() { }
-    public ParameterConfigurationList(IEnumerable<IParameterConfiguration> collection) : base(collection) { }
-    [StorableConstructor]
-    protected ParameterConfigurationList(bool deserializing) : base(deserializing) { }
-    
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterSet.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterSet.cs	(revision 4539)
+++ 	(revision )
@@ -1,44 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class ParameterSet : Item, IParameterSet {
-    [Storable]
-    private List<IParameterConfiguration> parameters;
-    public IEnumerable<IParameterConfiguration> Parameters {
-      get { return parameters; }
-    }
-
-    public ParameterSet() {
-      this.parameters = new List<IParameterConfiguration>();
-    }
-
-    [StorableConstructor]
-    protected ParameterSet(bool deserializing) : base(deserializing) { }
-
-    public ParameterSet(ParameterConfigurationList parametersToOptimize, IRandom random)
-      : this() {
-      foreach (IParameterConfiguration config in parametersToOptimize.CheckedItems) {
-        IParameterConfiguration clone = (IParameterConfiguration)config.Clone();
-        clone.SetParameterWithRandomValue(random);
-        parameters.Add(clone);
-      }
-    }
-
-    #region Cloning
-    public override Common.IDeepCloneable Clone(Common.Cloner cloner) {
-      ParameterSet clone = (ParameterSet)base.Clone(cloner);
-      clone.parameters = new List<IParameterConfiguration>();
-      foreach (var param in this.parameters) {
-        clone.parameters.Add((IParameterConfiguration)param.Clone(cloner));
-      }
-      return clone;
-    }
-    #endregion
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RootParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RootParameterConfiguration.cs	(revision 4830)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RootParameterConfiguration.cs	(revision 4830)
@@ -0,0 +1,69 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  /// <summary>
+  /// This class does not have a ParameterName, because its the root element of the ParameterConfiguration-Tree
+  /// It only deals with child-ParameterConfigurations
+  /// </summary>
+  [StorableClass]
+  public class RootParameterConfiguration : ParameterConfiguration {
+
+    public new IParameterizedNamedItem Value {
+      get { return (IParameterizedNamedItem)base.Value; }
+      set { base.Value = value; }
+    }
+
+    public RootParameterConfiguration(IParameterizedNamedItem rootItem) {
+      this.OptimizationEnabled = true;
+      this.Value = rootItem;
+    }
+
+    public RootParameterConfiguration() { }
+    [StorableConstructor]
+    protected RootParameterConfiguration(bool deserializing) { }
+    protected RootParameterConfiguration(RootParameterConfiguration original, Cloner cloner) : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RootParameterConfiguration(this, cloner);
+    }
+
+    public override IParameter Parameter {
+      get { return null; }
+    }
+
+    #region INamedItem Properties
+    public override string Name {
+      get { return Value.Name; }
+      set { throw new NotSupportedException(); }
+    }
+    public override string Description {
+      get { return Value.Description; }
+      set { throw new NotSupportedException(); }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override string ItemDescription {
+      get { return Value.ItemDescription; }
+    }
+    public override System.Drawing.Image ItemImage {
+      get { return Value.ItemImage; }
+    }
+    public override string ItemName {
+      get { return Value.ItemName; }
+    }
+    public override Version ItemVersion {
+      get { return Value.ItemVersion; }
+    }
+    #endregion
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueTypeParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueTypeParameterConfiguration.cs	(revision 4830)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueTypeParameterConfiguration.cs	(revision 4830)
@@ -0,0 +1,80 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+using HeuristicLab.Collections;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public abstract class ValueTypeParameterConfiguration<T> : ParameterConfiguration where T : class, IItem, IStringConvertibleValue, IDeepCloneable {
+    [Storable]
+    private IItemList<IRange<T>> ranges;
+    public IItemList<IRange<T>> Ranges {
+      get { return ranges; }
+    }
+
+    public ValueTypeParameterConfiguration(ParameterConfiguration parentConfiguration, string parameterName, IItem value) : base(parentConfiguration, parameterName, value) {
+      this.ranges = new ItemList<IRange<T>>();
+      this.ranges.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IRange<T>>>(ranges_ItemsAdded);
+      this.ranges.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IRange<T>>>(ranges_ItemsRemoved);
+      this.ranges.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IRange<T>>>(ranges_CollectionReset);
+    }
+
+    protected ValueTypeParameterConfiguration() { }
+    [StorableConstructor]
+    protected ValueTypeParameterConfiguration(bool deserializing) : base(deserializing) { }
+    protected ValueTypeParameterConfiguration(ValueTypeParameterConfiguration<T> original, Cloner cloner) : base(original, cloner) {
+      this.ranges = cloner.Clone(original.Ranges);
+    }
+
+    void ranges_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<IRange<T>>> e) {
+      foreach (var i in e.Items) {
+        DeregisterItemEvents(i.Value);
+      }
+      OnStringChanged(sender, e);
+    }
+
+    void ranges_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IRange<T>>> e) {
+      foreach (var i in e.Items) {
+        DeregisterItemEvents(i.Value);
+      }
+      OnStringChanged(sender, e);
+    }
+
+    void ranges_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IRange<T>>> e) {
+      foreach (var i in e.Items) {
+        RegisterItemEvents(i.Value);
+      }
+      OnStringChanged(sender, e);
+    }
+
+    private void DeregisterItemEvents(IRange<T> range) {
+      range.ToStringChanged -= new EventHandler(range_ToStringChanged);
+    }
+    private void RegisterItemEvents(IRange<T> range) {
+      range.ToStringChanged += new EventHandler(range_ToStringChanged);
+    }
+
+    public IntValue GetRandomValue() {
+      return new IntValue(0);
+    }
+    
+    void range_ToStringChanged(object sender, EventArgs e) {
+      OnStringChanged(sender, e);
+    }
+
+    public override string ToString() {
+      return string.Format("{0}: ({1})", base.ToString(), string.Join(",", ranges.Select(r => r.ToString()).ToArray()));
+    }
+
+    //public override void SetRandomValue(IRandom random) {
+    //  int rangeIndex = random.Next(ranges.Count);
+    //  int value = random.Next(ranges.ElementAt(rangeIndex).LowerBound.Value, ranges.ElementAt(rangeIndex).UpperBound.Value); // TODO: respect StepSize parameter
+    //  this.Parameter.ActualValue = new IntValue(value);
+    //}
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs	(revision 4539)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs	(revision 4830)
@@ -10,4 +10,5 @@
 using HeuristicLab.Optimization;
 using System.Threading;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -18,4 +19,6 @@
   [StorableClass]
   public class MetaOptimizationEvaluator : SingleSuccessorOperator, IMetaOptimizationEvaluator {
+    private const string RepetitionsParameterName = "Repetitions";
+
     private bool algorithmStopped;
 
@@ -23,30 +26,62 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-
     public ILookupParameter<IAlgorithm> AlgorithmParameter {
       get { return (ILookupParameter<IAlgorithm>)Parameters["Algorithm"]; }
     }
-    public ILookupParameter<IParameterSet> ParameterSetParameter {
-      get { return (ILookupParameter<IParameterSet>)Parameters["ParameterSet"]; }
+    public ILookupParameter<IItemList<IProblem>> ProblemsParameter {
+      get { return (ILookupParameter<IItemList<IProblem>>)Parameters["Problems"]; }
+    }
+    public ILookupParameter<IParameterConfiguration> ParameterConfigurationParameter {
+      get { return (ILookupParameter<IParameterConfiguration>)Parameters["ParameterConfiguration"]; }
+    }
+    public ValueParameter<IntValue> RepetitionsParameter {
+      get { return (ValueParameter<IntValue>)Parameters[RepetitionsParameterName]; }
     }
 
-    public MetaOptimizationEvaluator()
-      : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the TSP solution."));
+    public IntValue Repetitions {
+      get { return RepetitionsParameter.Value; }
+      set { RepetitionsParameter.Value = value; }
+    }
+
+    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<IParameterSet>("ParameterSet", "Missing description."));
+      Parameters.Add(new LookupParameter<IItemList<IProblem>>("Problems", "Missing description."));
+      Parameters.Add(new LookupParameter<IParameterConfiguration>("ParameterConfiguration", "Missing description."));
+      Parameters.Add(new ValueParameter<IntValue>(RepetitionsParameterName, "Number of evaluations for one individual.", new IntValue(3)));
+    }
+
+    [StorableConstructor]
+    protected MetaOptimizationEvaluator(bool deserializing) : base(deserializing) { }
+    protected MetaOptimizationEvaluator(MetaOptimizationEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+      this.algorithmStopped = original.algorithmStopped;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MetaOptimizationEvaluator(this, cloner);
     }
 
     public override IOperation Apply() {
       AlgorithmParameter.ActualValue.Prepare();
-      ParametrizeAlgorithm();
+      //ParameterizeAlgorithm();
+      ParameterConfigurationParameter.ActualValue.Parameterize(AlgorithmParameter.ActualValue);
       algorithmStopped = false;
       AlgorithmParameter.ActualValue.Stopped += new EventHandler(ActualValue_Stopped);
-      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)
+
+      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;
       }
-      AlgorithmParameter.ActualValue.Stopped -= new EventHandler(ActualValue_Stopped);
-      this.QualityParameter.ActualValue = (DoubleValue)AlgorithmParameter.ActualValue.Results["BestQuality"].Value;
+
+      double qualityAvg = qualitySum / ProblemsParameter.ActualValue.Count;
+      this.QualityParameter.ActualValue = new DoubleValue(qualityAvg);
+
       return base.Apply();
     }
@@ -56,13 +91,13 @@
     }
 
-    private void ParametrizeAlgorithm() {
-      foreach (IParameterConfiguration parameter in ParameterSetParameter.ActualValue.Parameters) {
-        if (parameter.Category == "Algorithm") {
-          this.AlgorithmParameter.ActualValue.Parameters[parameter.Parameter.Name].ActualValue = parameter.Parameter.ActualValue;
-        } else if (parameter.Category == "Problem") {
-          this.AlgorithmParameter.ActualValue.Problem.Parameters[parameter.Parameter.Name].ActualValue = parameter.Parameter.ActualValue;
-        }
-      }
-    }
+    //private void ParameterizeAlgorithm() {
+    //  foreach (IParameterConfiguration parameter in ParameterVectorParameter.ActualValue) {
+    //    if (typeof(IAlgorithm).IsAssignableFrom(parameter.OperatorType)) {
+    //      this.AlgorithmParameter.ActualValue.Parameters[parameter.Parameter.Name].ActualValue = parameter.Parameter.ActualValue;
+    //    } else if (typeof(IProblem).IsAssignableFrom(parameter.OperatorType)) {
+    //      this.AlgorithmParameter.ActualValue.Problem.Parameters[parameter.Parameter.Name].ActualValue = parameter.Parameter.ActualValue;
+    //    }
+    //  }
+    //}
   }
 }
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 4539)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj	(revision 4830)
@@ -88,21 +88,19 @@
   <ItemGroup>
     <Compile Include="Analyzers\BestQualityAnalyzer.cs" />
-    <Compile Include="Creators\RandomParameterSetCreator.cs" />
-    <Compile Include="Encodings\BooleanParameterConfiguration.cs" />
-    <Compile Include="Encodings\Crossovers\ParameterSetCrossover.cs" />
-    <Compile Include="Interfaces\IParameterSetOperator.cs" />
-    <Compile Include="NumericRangeList.cs" />
-    <Compile Include="Encodings\EnumerableParameterConfiguration.cs" />
-    <Compile Include="Interfaces\INumericRange.cs" />
-    <Compile Include="Encodings\NumericParameterConfiguration.cs" />
-    <Compile Include="Encodings\ParameterSet.cs" />
+    <Compile Include="Interfaces\IParameterConfigurationCreator.cs" />
+    <Compile Include="Creators\RandomParameterConfigurationCreator.cs" />
+    <Compile Include="Encodings\Crossovers\ParameterVectorCrossover.cs" />
+    <Compile Include="Encodings\IntValueParameterConfiguration.cs" />
+    <Compile Include="Encodings\ValueTypeParameterConfiguration.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Encodings\RootParameterConfiguration.cs" />
+    <Compile Include="Interfaces\IParameterConfigurationOperator.cs" />
+    <Compile Include="Interfaces\IRange.cs" />
     <Compile Include="Evaluators\MetaOptimizationEvaluator.cs" />
     <Compile Include="Interfaces\IMetaOptimizationEvaluator.cs" />
-    <Compile Include="Interfaces\IParameterSet.cs" />
-    <Compile Include="Interfaces\IParameterSetCreator.cs" />
     <Compile Include="Interfaces\IParameterConfiguration.cs" />
     <Compile Include="Encodings\ParameterConfiguration.cs" />
-    <Compile Include="Encodings\ParameterConfigurationList.cs" />
-    <Compile Include="NumericRange.cs" />
+    <Compile Include="Range.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="MetaOptimizationProblem.cs" />
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/INumericRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/INumericRange.cs	(revision 4539)
+++ 	(revision )
@@ -1,19 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Data;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  public interface INumericRange : IItem {
-    IntValue LowerBound { get; set; }
-    IntValue UpperBound { get; set; }
-    IntValue StepSize { get; set; }
-
-    event EventHandler LowerBoundChanged;
-    event EventHandler UpperBoundChanged;
-    event EventHandler StepSizeChanged;
-
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfiguration.cs	(revision 4539)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfiguration.cs	(revision 4830)
@@ -7,8 +7,15 @@
 namespace HeuristicLab.Problems.MetaOptimization {
   public interface IParameterConfiguration : INamedItem {
-    IParameter Parameter { get; set; }
-    string Category { get; set; }
+    bool OptimizationEnabled { get; set; }
+    string ParameterName { get; set; }
+    IParameter Parameter { get; }
+    IItem Value { get; set; }
+    IItemList<IParameterConfiguration> ChildParameterConfigurations { get; }
 
-    void SetParameterWithRandomValue(IRandom random);
+    void Parameterize(IParameterizedItem parameterizedItem);
+
+    event EventHandler OptimizationEnabledChanged;
+    event EventHandler ValueChanging;
+    event EventHandler ValueChanged;
   }
 }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationCreator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationCreator.cs	(revision 4830)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationCreator.cs	(revision 4830)
@@ -0,0 +1,10 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  public interface IParameterConfigurationCreator : ISolutionCreator {
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationOperator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationOperator.cs	(revision 4830)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationOperator.cs	(revision 4830)
@@ -0,0 +1,12 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  /// <summary>
+  /// An interface which represents an operator dealing with parameter sets.
+  /// </summary>
+  public interface IParameterConfigurationOperator : IOperator { }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterSet.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterSet.cs	(revision 4539)
+++ 	(revision )
@@ -1,11 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  public interface IParameterSet : IItem {
-    IEnumerable<IParameterConfiguration> Parameters { get; }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterSetCreator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterSetCreator.cs	(revision 4539)
+++ 	(revision )
@@ -1,15 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Optimization;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  /// <summary>
-  /// An interface which represents an operator for creating permutations.
-  /// </summary>
-  public interface IParameterSetCreator : ISolutionCreator {
-    ParameterConfigurationList ParametersToOptimize { get; set; }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterSetOperator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterSetOperator.cs	(revision 4539)
+++ 	(revision )
@@ -1,12 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  /// <summary>
-  /// An interface which represents an operator dealing with parameter sets.
-  /// </summary>
-  public interface IParameterSetOperator : IOperator { }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IRange.cs	(revision 4830)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IRange.cs	(revision 4830)
@@ -0,0 +1,19 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  public interface IRange<T> : IItem where T : class, IItem, IStringConvertibleValue, IDeepCloneable {
+    T LowerBound { get; set; }
+    T UpperBound { get; set; }
+    T StepSize { get; set; }
+
+    event EventHandler LowerBoundChanged;
+    event EventHandler UpperBoundChanged;
+    event EventHandler StepSizeChanged;
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 4539)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 4830)
@@ -36,156 +36,78 @@
   [Creatable("Problems")]
   [StorableClass]
-  public sealed class MetaOptimizationProblem : ParameterizedNamedItem, ISingleObjectiveProblem, IStorableContent {
-    public string Filename { get; set; }
-
-    public override Image ItemImage {
-      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Type; }
-    }
+  public sealed class MetaOptimizationProblem : SingleObjectiveProblem<IMetaOptimizationEvaluator, IParameterConfigurationCreator> {
+    private const string AlgorithmParameterName = "Algorithm";
+    private const string ProblemsParameterName = "Problems";
+    private const string AlgorithmParameterConfigurationParameterName = "AlgorithmParameterConfiguration";
+    private const string ProblemParametersConfigurationParameterName = "ProblemParametersConfiguration";
 
     #region Parameter Properties
-
-    public ValueParameter<IntValue> RepetitionsParameter {
-      get { return (ValueParameter<IntValue>)Parameters["Repetitions"]; }
+    public ValueParameter<IAlgorithm> AlgorithmParameter {
+      get { return (ValueParameter<IAlgorithm>)Parameters[AlgorithmParameterName]; }
     }
-
-    public ValueParameter<IParameterSetCreator> SolutionCreatorParameter {
-      get { return (ValueParameter<IParameterSetCreator>)Parameters["SolutionCreator"]; }
+    public ValueParameter<IItemList<ISingleObjectiveProblem>> ProblemsParameter {
+      get { return (ValueParameter<IItemList<ISingleObjectiveProblem>>)Parameters[ProblemsParameterName]; }
     }
-    IParameter IProblem.SolutionCreatorParameter {
-      get { return SolutionCreatorParameter; }
+    public ValueParameter<IParameterConfiguration> AlgorithmParameterConfigurationParameter {
+      get { return (ValueParameter<IParameterConfiguration>)Parameters[AlgorithmParameterConfigurationParameterName]; }
     }
-
-    public ValueParameter<IMetaOptimizationEvaluator> EvaluatorParameter {
-      get { return (ValueParameter<IMetaOptimizationEvaluator>)Parameters["Evaluator"]; }
-    }
-    IParameter IProblem.EvaluatorParameter {
-      get { return EvaluatorParameter; }
-    }
-
-    public OptionalValueParameter<ParameterSet> BestKnownSolutionParameter {
-      get { return (OptionalValueParameter<ParameterSet>)Parameters["BestKnownSolution"]; }
-    }
-
-    public ValueParameter<BoolValue> MaximizationParameter {
-      get { return (ValueParameter<BoolValue>)Parameters["Maximization"]; }
-    }
-    IParameter ISingleObjectiveProblem.MaximizationParameter {
-      get { return MaximizationParameter; }
-    }
-
-    public OptionalValueParameter<DoubleValue> BestKnownQualityParameter {
-      get { return (OptionalValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
-    }
-    IParameter ISingleObjectiveProblem.BestKnownQualityParameter {
-      get { return BestKnownQualityParameter; }
-    }
-
-    public ValueParameter<IAlgorithm> AlgorithmParameter {
-      get { return (ValueParameter<IAlgorithm>)Parameters["Algorithm"]; }
-    }
-    public ValueParameter<ParameterConfigurationList> ParametersToOptimizeParameter {
-      get { return (ValueParameter<ParameterConfigurationList>)Parameters["ParametersToOptimize"]; }
-    }
+    //public ValueParameter<IItemList<IParameterConfiguration>> ProblemParametersConfigurationParameter {
+    //  get { return (ValueParameter<IItemList<IParameterConfiguration>>)Parameters[ProblemParametersConfigurationParameterName]; }
+    //}
     #endregion
 
     #region Properties
-
-    public IntValue Repetitions {
-      get { return RepetitionsParameter.Value; }
-      set { RepetitionsParameter.Value = value; }
-    }
-
-    public IEnumerable<IOperator> Operators {
-      get { return operators; }
-    }
-
-    IEvaluator IProblem.Evaluator {
-      get { return EvaluatorParameter.Value; }
-    }
-    public IMetaOptimizationEvaluator Evaluator {
-      get { return EvaluatorParameter.Value; }
-      set { EvaluatorParameter.Value = value; }
-    }
-
-    ISolutionCreator IProblem.SolutionCreator {
-      get { return SolutionCreatorParameter.Value; }
-    }
-    public IParameterSetCreator SolutionCreator {
-      get { return SolutionCreatorParameter.Value; }
-    }
-
-    ISingleObjectiveEvaluator ISingleObjectiveProblem.Evaluator {
-      get { return this.Evaluator; }
-    }
-
-    public DoubleValue BestKnownQuality {
-      get { return BestKnownQualityParameter.Value; }
-      set { BestKnownQualityParameter.Value = value; }
-    }
-    public ParameterSet BestKnownSolution {
-      get { return BestKnownSolutionParameter.Value; }
-      set { BestKnownSolutionParameter.Value = value; }
-    }
-
     public IAlgorithm Algorithm {
       get { return AlgorithmParameter.Value; }
       set { AlgorithmParameter.Value = value; }
     }
-
-    public ParameterConfigurationList ParametersToOptimize {
-      get { return ParametersToOptimizeParameter.Value; }
-      set { ParametersToOptimizeParameter.Value = value; }
+    public IItemList<ISingleObjectiveProblem> Problems {
+      get { return ProblemsParameter.Value; }
+      set { ProblemsParameter.Value = value; }
     }
-
-    private BestQualityAnalyzer BestQualityAnalyzer {
-      get { return operators.OfType<BestQualityAnalyzer>().FirstOrDefault(); }
+    public IParameterConfiguration AlgorithmParameterConfiguration {
+      get { return AlgorithmParameterConfigurationParameter.Value; }
+      set { AlgorithmParameterConfigurationParameter.Value = value; }
     }
+    //public IItemList<IParameterConfiguration> ProblemParametersConfiguration {
+    //  get { return ProblemParametersConfigurationParameter.Value; }
+    //  set { ProblemParametersConfigurationParameter.Value = value; }
+    //}
     #endregion
 
-    [Storable]
-    private List<IOperator> operators;
+    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<IParameterConfiguration>(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>()));
+      
+      Maximization = new BoolValue(false);
+      SolutionCreator = new RandomParameterConfigurationCreator();
+      Evaluator = new MetaOptimizationEvaluator();
+
+      InitializeOperators();
+      RegisterParameterEvents();
+      ParameterizeSolutionCreator();
+      ParameterizeEvaluator();
+      ParameterizeOperators();
+    }
 
     [StorableConstructor]
     private MetaOptimizationProblem(bool deserializing) : base(deserializing) { }
-    public MetaOptimizationProblem()
-      : base() {
-
-      IParameterSetCreator creator = new RandomParameterSetCreator();
-      MetaOptimizationEvaluator evaluator = new MetaOptimizationEvaluator();
-      ParameterConfigurationList parametersToOptimize = new ParameterConfigurationList();
-
-      Parameters.Add(new ValueParameter<BoolValue>("Maximization", "Set to false as the Traveling Salesman Problem is a minimization problem.", new BoolValue(false)));
-      Parameters.Add(new ValueParameter<IntValue>("Repetitions", "Number of evaluations for one individual.", new IntValue(3)));
-      Parameters.Add(new ValueParameter<IParameterSetCreator>("SolutionCreator", "The operator which should be used to create new TSP solutions.", creator));
-      Parameters.Add(new ValueParameter<IMetaOptimizationEvaluator>("Evaluator", "The operator which should be used to evaluate TSP solutions.", evaluator));
-      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this TSP instance."));
-      Parameters.Add(new OptionalValueParameter<ParameterSet>("BestKnownSolution", "The best known solution of this TSP instance."));
-
-      Parameters.Add(new ValueParameter<IAlgorithm>("Algorithm", "The algorithm and problem which's parameters should be optimized."));
-      Parameters.Add(new ValueParameter<ParameterConfigurationList>("ParametersToOptimize", "List of parameters that should be optimized.", parametersToOptimize));
-
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
-
-      InitializeOperators();
-      AttachEventHandlers();
+    private MetaOptimizationProblem(MetaOptimizationProblem original, Cloner cloner) : base(original, cloner) {
+      // todo
+      this.RegisterParameterEvents();
     }
-
-    #region Cloning
     public override IDeepCloneable Clone(Cloner cloner) {
-      MetaOptimizationProblem clone = (MetaOptimizationProblem)base.Clone(cloner);
-      clone.operators = operators.Select(x => (IOperator)cloner.Clone(x)).ToList();
-      // todo
-      clone.AttachEventHandlers();
-      return clone;
+      return new MetaOptimizationProblem(this, cloner);
     }
-    #endregion
 
     #region Helpers
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserializationHook() {
-      AttachEventHandlers();
+      RegisterParameterEvents();
     }
-    private void AttachEventHandlers() {
+    private void RegisterParameterEvents() {
       SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
       EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
@@ -194,80 +116,23 @@
     }
     private void InitializeOperators() {
-      operators = new List<IOperator>();
-      operators.Add(new BestQualityAnalyzer());
-      ParameterizeAnalyzer();
-      operators.AddRange(ApplicationManager.Manager.GetInstances<IParameterSetOperator>().Cast<IOperator>());
-      ParameterizeOperators();
-
-      //UpdateMoveEvaluators();
-      //InitializeMoveGenerators();
+      Operators.AddRange(ApplicationManager.Manager.GetInstances<IParameterConfigurationOperator>().Cast<IOperator>());
+      Operators.Add(new BestParameterConfigurationAnalyzer());
     }
     private void ParameterizeSolutionCreator() {
-      SolutionCreator.ParametersToOptimize = this.ParametersToOptimize;
+      //SolutionCreator.ParametersToOptimize = this.ParametersToOptimize;
     }
     private void ParameterizeEvaluator() {
+      ((MetaOptimizationEvaluator)Evaluator).ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
     }
     private void ParameterizeAnalyzer() {
-      BestQualityAnalyzer.ResultsParameter.ActualName = "Results";
+      //BestQualityAnalyzer.ResultsParameter.ActualName = "Results";
     }
     private void ParameterizeOperators() {
+      
     }
 
-    private void AddAlgorithmParameters() {
-      foreach (IParameter parameter in Algorithm.Parameters) {
-        this.ParametersToOptimize.Add(new NumericParameterConfiguration(parameter, "Algorithm"), false);
-      }
-    }
-    private void RemoveAlgorithmParameters() {
-      foreach (IParameter parameter in Algorithm.Parameters) {
-        IParameterConfiguration parameterConfiguration = this.ParametersToOptimize.Single(p => p.Parameter == parameter);
-        if (parameterConfiguration != null) {
-          this.ParametersToOptimize.Remove(parameterConfiguration);
-        }
-      }
-    }
-    private void ClearAlgorithmParameters() {
-      //this.ParametersToOptimize.Clear();
-    }
-
-    private void AddProblemParameters() {
-      foreach (IParameter parameter in Algorithm.Problem.Parameters) {
-        this.ParametersToOptimize.Add(new NumericParameterConfiguration(parameter, "Problem"), false);
-      }
-    }
-    private void RemoveProblemParameters() {
-      foreach (IParameter parameter in Algorithm.Problem.Parameters) {
-        IParameterConfiguration parameterConfiguration = this.ParametersToOptimize.Single(p => p.Parameter == parameter);
-        if (parameterConfiguration != null) {
-          this.ParametersToOptimize.Remove(parameterConfiguration);
-        }
-      }
-    }
-    private void ClearProblemParameters() {
-      //this.ParametersToOptimize.Clear();
-    }
     #endregion
 
     #region Events
-    public event EventHandler SolutionCreatorChanged;
-    private void OnSolutionCreatorChanged() {
-      EventHandler handler = SolutionCreatorChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler EvaluatorChanged;
-    private void OnEvaluatorChanged() {
-      EventHandler handler = EvaluatorChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler OperatorsChanged;
-    private void OnOperatorsChanged() {
-      EventHandler handler = OperatorsChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler Reset;
-    private void OnReset() {
-      EventHandler handler = Reset;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
 
     private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
@@ -288,8 +153,7 @@
     }
     void BaseLevelAlgorithmParameter_ValueChanged(object sender, EventArgs e) {
-      ClearAlgorithmParameters();
       if (Algorithm != null) {
         Algorithm.ProblemChanged += new EventHandler(BaseLevelAlgorithm_ProblemChanged);
-        AddAlgorithmParameters(); // TODO: When to Detach?
+        AlgorithmParameterConfiguration = ParameterConfiguration.Create(Algorithm);
       }
       BaseLevelAlgorithm_ProblemChanged(sender, e);
@@ -297,8 +161,8 @@
 
     void BaseLevelAlgorithm_ProblemChanged(object sender, EventArgs e) {
-      ClearProblemParameters();
-      if (Algorithm.Problem != null) {
-        AddProblemParameters();
-      }
+      //ClearProblemParameters();
+      //if (Algorithm.Problem != null) {
+      //  AddProblemParameters();
+      //}
     }
     #endregion
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/NumericRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/NumericRange.cs	(revision 4539)
+++ 	(revision )
@@ -1,129 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class NumericRange : Item, INumericRange {
-    [Storable]
-    private IntValue lowerBound;
-    public IntValue LowerBound {
-      get { return lowerBound; }
-      set {
-        if (lowerBound != value) {
-          if (lowerBound != null) {
-            lowerBound.ValueChanged -= new EventHandler(lowerBound_ValueChanged);
-          }
-          lowerBound = value;
-          if (lowerBound != null) {
-            lowerBound.ValueChanged += new EventHandler(lowerBound_ValueChanged);
-          }
-          OnLowerBoundChanged();
-        }
-      }
-    }
-
-    [Storable]
-    private IntValue upperBound;
-    public IntValue UpperBound {
-      get { return upperBound; }
-      set {
-        if (upperBound != value) {
-          if (upperBound != null) {
-            upperBound.ValueChanged -= new EventHandler(upperBound_ValueChanged);
-          }
-          upperBound = value;
-          if (upperBound != null) {
-            upperBound.ValueChanged += new EventHandler(upperBound_ValueChanged);
-          }
-          OnUpperBoundChanged();
-        }
-      }
-    }
-
-    [Storable]
-    private IntValue stepSize;
-    public IntValue StepSize {
-      get { return stepSize; }
-      set {
-        if (stepSize != value) {
-          if (stepSize != null) {
-            stepSize.ValueChanged -= new EventHandler(upperBound_ValueChanged);
-          }
-          stepSize = value;
-          if (stepSize != null) {
-            stepSize.ValueChanged += new EventHandler(stepSize_ValueChanged);
-          }
-          OnStepSizeChanged();
-        }
-      }
-    }
-
-    public NumericRange() {
-      LowerBound = new IntValue(0);
-      UpperBound = new IntValue(0);
-      StepSize = new IntValue(1);
-    }
-
-    [StorableConstructor]
-    protected NumericRange(bool deserializing) : base(deserializing) { }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (lowerBound != null) {
-        lowerBound.ValueChanged += new EventHandler(lowerBound_ValueChanged);
-      }
-      if (upperBound != null) {
-        upperBound.ValueChanged += new EventHandler(upperBound_ValueChanged);
-      }
-      if (stepSize != null) {
-        stepSize.ValueChanged += new EventHandler(stepSize_ValueChanged);
-      }
-    }
-
-    void lowerBound_ValueChanged(object sender, EventArgs e) {
-      OnToStringChanged();
-    }
-    void upperBound_ValueChanged(object sender, EventArgs e) {
-      OnToStringChanged();
-    }
-    void stepSize_ValueChanged(object sender, EventArgs e) {
-      OnToStringChanged();
-    }
-
-    public event EventHandler LowerBoundChanged;
-    private void OnLowerBoundChanged() {
-      var handler = LowerBoundChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    public event EventHandler UpperBoundChanged;
-    private void OnUpperBoundChanged() {
-      var handler = UpperBoundChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler StepSizeChanged;
-    private void OnStepSizeChanged() {
-      var handler = StepSizeChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    public override string ToString() {
-      return string.Format("[{0},{1}:{2}]", LowerBound.ToString(), UpperBound.ToString(), StepSize.ToString());
-    }
-
-    #region Cloning
-    public override Common.IDeepCloneable Clone(Common.Cloner cloner) {
-      NumericRange clone = (NumericRange)base.Clone(cloner);
-      clone.LowerBound = (IntValue)this.LowerBound.Clone();
-      clone.UpperBound = (IntValue)this.UpperBound.Clone();
-      clone.StepSize = (IntValue)this.StepSize.Clone();
-      return base.Clone(cloner);
-    }
-    #endregion
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/NumericRangeList.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/NumericRangeList.cs	(revision 4539)
+++ 	(revision )
@@ -1,18 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  [Item("NumericRangeList", "Represents a list of numeric ranges.")]
-  public class NumericRangeList : ItemCollection<INumericRange> {
-    public NumericRangeList() : base() { }
-    public NumericRangeList(IEnumerable<INumericRange> collection) : base(collection) { }
-    [StorableConstructor]
-    protected NumericRangeList(bool deserializing) : base(deserializing) { }
-    
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Range.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Range.cs	(revision 4830)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Range.cs	(revision 4830)
@@ -0,0 +1,128 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class Range<T> : Item, IRange<T> where T : class, IItem, IStringConvertibleValue, IDeepCloneable {
+    [Storable]
+    private T lowerBound;
+    public T LowerBound {
+      get { return lowerBound; }
+      set {
+        if (lowerBound != value) {
+          if (lowerBound != null) {
+            lowerBound.ValueChanged -= new EventHandler(lowerBound_ValueChanged);
+          }
+          lowerBound = value;
+          if (lowerBound != null) {
+            lowerBound.ValueChanged += new EventHandler(lowerBound_ValueChanged);
+          }
+          OnLowerBoundChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private T upperBound;
+    public T UpperBound {
+      get { return upperBound; }
+      set {
+        if (upperBound != value) {
+          if (upperBound != null) {
+            upperBound.ValueChanged -= new EventHandler(upperBound_ValueChanged);
+          }
+          upperBound = value;
+          if (upperBound != null) {
+            upperBound.ValueChanged += new EventHandler(upperBound_ValueChanged);
+          }
+          OnUpperBoundChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private T stepSize;
+    public T StepSize {
+      get { return stepSize; }
+      set {
+        if (stepSize != value) {
+          if (stepSize != null) {
+            stepSize.ValueChanged -= new EventHandler(upperBound_ValueChanged);
+          }
+          stepSize = value;
+          if (stepSize != null) {
+            stepSize.ValueChanged += new EventHandler(stepSize_ValueChanged);
+          }
+          OnStepSizeChanged();
+        }
+      }
+    }
+
+    public Range() {
+      LowerBound = Activator.CreateInstance<T>();
+      UpperBound = Activator.CreateInstance<T>();
+      StepSize = Activator.CreateInstance<T>(); // todo: stepsize should be != 0
+    }
+
+    [StorableConstructor]
+    protected Range(bool deserializing) : base(deserializing) { }
+    protected Range(Range<T> original, Cloner cloner) : base(original, cloner) {
+      this.LowerBound = cloner.Clone(original.LowerBound);
+      this.UpperBound = cloner.Clone(original.UpperBound);
+      this.StepSize = cloner.Clone(original.StepSize);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Range<T>(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (lowerBound != null) {
+        lowerBound.ValueChanged += new EventHandler(lowerBound_ValueChanged);
+      }
+      if (upperBound != null) {
+        upperBound.ValueChanged += new EventHandler(upperBound_ValueChanged);
+      }
+      if (stepSize != null) {
+        stepSize.ValueChanged += new EventHandler(stepSize_ValueChanged);
+      }
+    }
+
+    void lowerBound_ValueChanged(object sender, EventArgs e) {
+      OnToStringChanged();
+    }
+    void upperBound_ValueChanged(object sender, EventArgs e) {
+      OnToStringChanged();
+    }
+    void stepSize_ValueChanged(object sender, EventArgs e) {
+      OnToStringChanged();
+    }
+
+    public event EventHandler LowerBoundChanged;
+    private void OnLowerBoundChanged() {
+      var handler = LowerBoundChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler UpperBoundChanged;
+    private void OnUpperBoundChanged() {
+      var handler = UpperBoundChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler StepSizeChanged;
+    private void OnStepSizeChanged() {
+      var handler = StepSizeChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public override string ToString() {
+      return string.Format("[{0},{1}:{2}]", LowerBound.ToString(), UpperBound.ToString(), StepSize.ToString());
+    }
+  }
+}
