Index: /branches/IslandALPS/IslandALPS/3.3/GroupedLayerOperator.cs
===================================================================
--- /branches/IslandALPS/IslandALPS/3.3/GroupedLayerOperator.cs	(revision 13685)
+++ /branches/IslandALPS/IslandALPS/3.3/GroupedLayerOperator.cs	(revision 13686)
@@ -115,5 +115,5 @@
     }
 
-    //TODO: Copied from ResultsHistoryWiper, When integrate create static apply method and delete this
+    //TODO: HL-INTEGRATION :Copied from ResultsHistoryWiper, When integrate create static apply method and delete this
     private static void ClearHistoryRecursively(ResultCollection results) {
       var values = results.Select(r => r.Value);
Index: /branches/IslandALPS/IslandALPS/3.3/HeuristicLab.Algorithms.IslandALPS-3.3.csproj
===================================================================
--- /branches/IslandALPS/IslandALPS/3.3/HeuristicLab.Algorithms.IslandALPS-3.3.csproj	(revision 13685)
+++ /branches/IslandALPS/IslandALPS/3.3/HeuristicLab.Algorithms.IslandALPS-3.3.csproj	(revision 13686)
@@ -105,8 +105,10 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="IslandAlpsAlgorithmMainLoop.cs" />
     <Compile Include="LayerMigrator.cs" />
+    <Compile Include="Offspring Selection\IslandAlpsOffspringSelectionAlgorithm.cs" />
+    <Compile Include="Offspring Selection\IslandAlpsOffspringSelectionAlgorithmMainLoop.cs" />
     <Compile Include="ResultsExtractor.cs" />
     <Compile Include="IslandALPSAlgorithm.cs" />
-    <Compile Include="IslandALPSAlgorthmsMainLoop.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -116,4 +118,5 @@
     <None Include="HeuristicLab.snk" />
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: /branches/IslandALPS/IslandALPS/3.3/IslandALPSAlgorithm.cs
===================================================================
--- /branches/IslandALPS/IslandALPS/3.3/IslandALPSAlgorithm.cs	(revision 13685)
+++ /branches/IslandALPS/IslandALPS/3.3/IslandALPSAlgorithm.cs	(revision 13686)
@@ -2,5 +2,4 @@
 using System.Collections.Generic;
 using System.Linq;
-using System.Security.Policy;
 using HeuristicLab.Algorithms.ALPS;
 using HeuristicLab.Analysis;
@@ -41,180 +40,152 @@
 
     #region ALPSParameter
-    private IValueParameter<IntValue> AgeGapParameter {
-      get { return (IValueParameter<IntValue>) Parameters["AgeGap"]; }
-    }
-    private IValueParameter<EnumValue<AgingScheme>> AgingSchemeParameter {
-      get { return (IValueParameter<EnumValue<AgingScheme>>)Parameters["AgingScheme"]; }
-    }
-    private IValueParameter<DoubleValue> AgeInheritanceParameter {
-      get { return (IValueParameter<DoubleValue>) Parameters["AgeInheritance"]; }
-    }
-    private IValueParameter<IntArray> AgeLimitsParameter {
-      get { return (IValueParameter<IntArray>) Parameters["AgeLimits"]; }
-    }
-    private IValueParameter<BoolValue> ReduceToPopulationSizeParameter {
-      get { return (IValueParameter<BoolValue>) Parameters["ReduceToPopulationSize"]; }
-    }
-    private IValueParameter<IntValue> NumberOfLayersParameter {
-      get { return (IValueParameter<IntValue>) Parameters["NumberOfLayers"]; }
-    }
-    private IValueParameter<MultiAnalyzer> LayerAnalyzerParameter {
-      get { return (IValueParameter<MultiAnalyzer>)Parameters["LayerAnalyzer"]; }
-    }
-    private IValueParameter<MultiAnalyzer> GroupAnalyzerParameter {
-      get { return (IValueParameter<MultiAnalyzer>)Parameters["GroupAnalyzer"]; }
-    }
-    private IValueParameter<BoolValue> PlusSelectionParameter {
-      get { return (IValueParameter<BoolValue>)Parameters["PlusSelection"]; }
-    }
+
+    public IValueParameter<IntValue> AgeGapParameter { get { return (IValueParameter<IntValue>) Parameters["AgeGap"]; } }
+
+    public IValueParameter<EnumValue<AgingScheme>> AgingSchemeParameter { get { return (IValueParameter<EnumValue<AgingScheme>>) Parameters["AgingScheme"]; } } 
+    public IValueParameter<DoubleValue> AgeInheritanceParameter {   get { return (IValueParameter<DoubleValue>) Parameters["AgeInheritance"]; } } 
+    public IValueParameter<IntArray> AgeLimitsParameter {   get { return (IValueParameter<IntArray>) Parameters["AgeLimits"]; }   } 
+    public IValueParameter<BoolValue> ReduceToPopulationSizeParameter {   get { return (IValueParameter<BoolValue>) Parameters["ReduceToPopulationSize"]; }   } 
+    public IValueParameter<IntValue> NumberOfLayersParameter {   get { return (IValueParameter<IntValue>) Parameters["NumberOfLayers"]; } } 
+    public IValueParameter<MultiAnalyzer> LayerAnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["LayerAnalyzer"]; } } 
+    public IValueParameter<MultiAnalyzer> GroupAnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["GroupAnalyzer"]; } } 
+    public IValueParameter<BoolValue> PlusSelectionParameter {   get { return (IValueParameter<BoolValue>) Parameters["PlusSelection"]; } } 
     #endregion
 
     #region IslandParameter
-    private IValueParameter<MultiAnalyzer> IslandAnalyzerParameter {
-      get { return (IValueParameter<MultiAnalyzer>) Parameters["IslandAnalyzer"]; }
-    }
-    private IValueParameter<IntValue> NumberOfIslandsParameter {
-      get { return (IValueParameter<IntValue>) Parameters["NumberOfIslands"]; }
-    }
-    private IValueParameter<PercentValue> MigrationRateParameter {
-      get { return (IValueParameter<PercentValue>)Parameters["MigrationRate"]; }
-    }
-    private IValueParameter<IntValue> MigrationIntervalParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MigrationInterval"]; }
-    }
-    public IConstrainedValueParameter<IMigrator> MigratorParameter {
-      get { return (IConstrainedValueParameter<IMigrator>)Parameters["Migrator"]; }
-    }
-    public IConstrainedValueParameter<ISelector> EmigrantsSelectorParameter {
-      get { return (IConstrainedValueParameter<ISelector>)Parameters["EmigrantsSelector"]; }
-    }
-    public IConstrainedValueParameter<IReplacer> ImmigrationReplacerParameter {
-      get { return (IConstrainedValueParameter<IReplacer>)Parameters["ImmigrationReplacer"]; }
-    }
+
+    public IValueParameter<MultiAnalyzer> IslandAnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["IslandAnalyzer"]; } } 
+    public IValueParameter<IntValue> NumberOfIslandsParameter {   get { return (IValueParameter<IntValue>) Parameters["NumberOfIslands"]; } } 
+    public IValueParameter<PercentValue> MigrationRateParameter {   get { return (IValueParameter<PercentValue>) Parameters["MigrationRate"]; } } 
+    public IValueParameter<IntValue> MigrationIntervalParameter {   get { return (IValueParameter<IntValue>) Parameters["MigrationInterval"]; } } 
+    public IConstrainedValueParameter<IMigrator> MigratorParameter {   get { return (IConstrainedValueParameter<IMigrator>) Parameters["Migrator"]; } } 
+    public IConstrainedValueParameter<ISelector> EmigrantsSelectorParameter {   get { return (IConstrainedValueParameter<ISelector>) Parameters["EmigrantsSelector"]; } } 
+    public IConstrainedValueParameter<IReplacer> ImmigrationReplacerParameter {   get { return (IConstrainedValueParameter<IReplacer>) Parameters["ImmigrationReplacer"]; } } 
     #endregion
 
     #region GeneralParameter
-    private IValueParameter<IntValue> SeedParameter {
-      get { return (IValueParameter<IntValue>) Parameters["Seed"]; }
-    }
-    private IValueParameter<BoolValue> SetSeedRandomlyParameter {
-      get { return (IValueParameter<BoolValue>) Parameters["SetSeedRandomly"]; }
-    }
-    private IValueParameter<IntValue> PopulationSizeParameter {
-      get { return (IValueParameter<IntValue>) Parameters["PopulationSize"]; }
-    }
-    private IValueParameter<MultiAnalyzer> AnalyzerParameter {
-      get { return (IValueParameter<MultiAnalyzer>) Parameters["Analyzer"]; }
-    }
-    public IConstrainedValueParameter<ISelector> SelectorParameter {
-      get { return (IConstrainedValueParameter<ISelector>) Parameters["Selector"]; }
-    }
-    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
-      get { return (IConstrainedValueParameter<ICrossover>) Parameters["Crossover"]; }
-    }
-    private IValueParameter<PercentValue> MutationProbabilityParameter {
-      get { return (IValueParameter<PercentValue>) Parameters["MutationProbability"]; }
-    }
-    public IConstrainedValueParameter<IManipulator> MutatorParameter {
-      get { return (IConstrainedValueParameter<IManipulator>) Parameters["Mutator"]; }
-    }
-    private IValueParameter<IntValue> ElitesParameter {
-      get { return (IValueParameter<IntValue>) Parameters["Elites"]; }
-    }
-    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
-      get { return (IFixedValueParameter<BoolValue>) Parameters["ReevaluateElites"]; }
-    }
-    private IValueParameter<MultiTerminator> TerminatorParameter {
-      get { return (IValueParameter<MultiTerminator>) Parameters["Terminator"]; }
-    }
-    #endregion
+
+    public IValueParameter<IntValue> SeedParameter {   get { return (IValueParameter<IntValue>) Parameters["Seed"]; } } 
+    public IValueParameter<BoolValue> SetSeedRandomlyParameter {   get { return (IValueParameter<BoolValue>) Parameters["SetSeedRandomly"]; } } 
+    public IValueParameter<IntValue> PopulationSizeParameter {   get { return (IValueParameter<IntValue>) Parameters["PopulationSize"]; } } 
+    public IValueParameter<MultiAnalyzer> AnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["Analyzer"]; } } 
+    public IConstrainedValueParameter<ISelector> SelectorParameter {   get { return (IConstrainedValueParameter<ISelector>) Parameters["Selector"]; } } 
+    public IConstrainedValueParameter<ICrossover> CrossoverParameter {   get { return (IConstrainedValueParameter<ICrossover>) Parameters["Crossover"]; } }
+    public IValueParameter<PercentValue> MutationProbabilityParameter {   get { return (IValueParameter<PercentValue>) Parameters["MutationProbability"]; } } 
+    public IConstrainedValueParameter<IManipulator> MutatorParameter {   get { return (IConstrainedValueParameter<IManipulator>) Parameters["Mutator"]; } }
+    public IValueParameter<IntValue> ElitesParameter {   get { return (IValueParameter<IntValue>) Parameters["Elites"]; } }
+    public IFixedValueParameter<BoolValue> ReevaluateElitesParameter {   get { return (IFixedValueParameter<BoolValue>) Parameters["ReevaluateElites"]; } }
+    public IValueParameter<MultiTerminator> TerminatorParameter {   get { return (IValueParameter<MultiTerminator>) Parameters["Terminator"]; } } 
+    #endregion
+
     #endregion
 
     #region Properties
+
     public IntValue Seed {
       get { return SeedParameter.Value; }
       set { SeedParameter.Value = value; }
     }
+
     public BoolValue SetSeedRandomly {
       get { return SetSeedRandomlyParameter.Value; }
       set { SetSeedRandomlyParameter.Value = value; }
     }
+
     public IntValue PopulationSize {
       get { return PopulationSizeParameter.Value; }
       set { PopulationSizeParameter.Value = value; }
     }
+
     public IntValue NumberOfIslands {
       get { return NumberOfIslandsParameter.Value; }
       set { NumberOfIslandsParameter.Value = value; }
     }
+
     public MultiAnalyzer Analyzer {
       get { return AnalyzerParameter.Value; }
       set { AnalyzerParameter.Value = value; }
     }
+
     public MultiAnalyzer IslandAnalyzer {
       get { return IslandAnalyzerParameter.Value; }
       set { IslandAnalyzerParameter.Value = value; }
     }
+
     public MultiAnalyzer LayerAnalyzer {
       get { return LayerAnalyzerParameter.Value; }
       set { LayerAnalyzerParameter.Value = value; }
     }
+
     public MultiAnalyzer GroupAnalyzer {
       get { return GroupAnalyzerParameter.Value; }
       set { GroupAnalyzerParameter.Value = value; }
     }
+
     public ISelector Selector {
       get { return SelectorParameter.Value; }
       set { SelectorParameter.Value = value; }
     }
+
     public ICrossover Crossover {
       get { return CrossoverParameter.Value; }
       set { CrossoverParameter.Value = value; }
     }
+
     public PercentValue MutationProbability {
       get { return MutationProbabilityParameter.Value; }
       set { MutationProbabilityParameter.Value = value; }
     }
+
     public IManipulator Mutator {
       get { return MutatorParameter.Value; }
       set { MutatorParameter.Value = value; }
     }
+
     public IntValue Elites {
       get { return ElitesParameter.Value; }
       set { ElitesParameter.Value = value; }
     }
+
     public bool ReevaluteElites {
       get { return ReevaluateElitesParameter.Value.Value; }
       set { ReevaluateElitesParameter.Value.Value = value; }
     }
+
     public MultiTerminator Terminators {
       get { return TerminatorParameter.Value; }
     }
+
     public EnumValue<AgingScheme> AgingScheme {
       get { return AgingSchemeParameter.Value; }
       set { AgingSchemeParameter.Value = value; }
     }
+
     public IntValue AgeGap {
       get { return AgeGapParameter.Value; }
       set { AgeGapParameter.Value = value; }
     }
+
     public DoubleValue AgeInheritance {
       get { return AgeInheritanceParameter.Value; }
       set { AgeInheritanceParameter.Value = value; }
     }
+
     public IntArray AgeLimits {
       get { return AgeLimitsParameter.Value; }
       set { AgeLimitsParameter.Value = value; }
     }
+
     public IntValue NumberOfLayers {
       get { return NumberOfLayersParameter.Value; }
       set { NumberOfLayersParameter.Value = value; }
     }
+
     #endregion
 
     #region Helper Properties
 
-    private IslandAlpsAlgorthmsMainLoop MainLoop {
-      get { return OperatorGraph.Iterate().OfType<IslandAlpsAlgorthmsMainLoop>().First(); }
+    private IslandAlpsAlgorithmMainLoop MainLoop {
+      get { return OperatorGraph.Iterate().OfType<IslandAlpsAlgorithmMainLoop>().First(); }
     }
 
@@ -246,6 +217,5 @@
 
     [StorableConstructor]
-    private IslandAlpsAlgorithm(bool deserializing) : base(deserializing) {
-    }
+    private IslandAlpsAlgorithm(bool deserializing) : base(deserializing) {}
 
     [StorableHook(HookType.AfterDeserialization)]
@@ -273,43 +243,6 @@
 
     public IslandAlpsAlgorithm() {
-      #region add Parameter
-      #region ALPSParameter
-      Parameters.Add(new ValueParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers.", new IntValue(5)));
-      Parameters.Add(new ValueParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent.", new DoubleValue(0.5)));
-      Parameters.Add(new ValueParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer.", new IntArray(new int[0])) { Hidden = true });
-      Parameters.Add(new ValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
-      Parameters.Add(new ValueParameter<BoolValue>("ReduceToPopulationSize", ".", new BoolValue(true)));
-
-      Parameters.Add(new ValueParameter<IntValue>("NumberOfLayers", "", new IntValue(10)));
-      Parameters.Add(new ValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
-      Parameters.Add(new ValueParameter<MultiAnalyzer>("GroupAnalyzer", "The operator used to analyze each layergroup.", new MultiAnalyzer()));
-      Parameters.Add(new ValueParameter<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation.", new BoolValue(false)));
-
-      #endregion
-      #region IslandParameter
-      Parameters.Add(new ValueParameter<IntValue>("NumberOfIslands", "The number of islands.", new IntValue(5)));
-      Parameters.Add(new ValueParameter<PercentValue>("MigrationRate", "How many individuals should migrate.", new PercentValue(0.15)));
-      Parameters.Add(new ValueParameter<IntValue>("MigrationInterval", "The number Generations before a migration occurs.", new IntValue(20)));
-      Parameters.Add(new ValueParameter<MultiAnalyzer>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer()));
-      Parameters.Add(new ConstrainedValueParameter<IMigrator>("Migrator", "The migration strategy."));
-      Parameters.Add(new ConstrainedValueParameter<ISelector>("EmigrantsSelector", "Selects the individuals that will be migrated."));
-      Parameters.Add(new ConstrainedValueParameter<IReplacer>("ImmigrationReplacer", "Selects the population from the unification of the original population and the immigrants."));
-
-      #endregion
-      #region GeneralParameter   
-      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
-      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
-      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
-      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
-      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
-      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
-      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
-      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
-      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
-      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
-      Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
-      #endregion
-
-      #endregion
+    
+      AddParameters();
 
       #region create Operators
@@ -330,5 +263,5 @@
       var globalEvaluatedSolutionsCounter = new DataReducer {Name = "Count GlobalSolutions"};
       var resultsCollector = new ResultsCollector();
-      var mainLoop = new IslandAlpsAlgorthmsMainLoop();
+      var mainLoop = new IslandAlpsAlgorithmMainLoop();
 
       #endregion
@@ -351,5 +284,4 @@
 
       #region Create Analyzers
-
       qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
       islandQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
@@ -360,9 +292,6 @@
       #region Create terminators
 
-      generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) {
-        Name = "Generations"
-      };
-      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less,
-        new IntValue(int.MaxValue)) {Name = "Evaluations"};
+      generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
+      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) {Name = "Evaluations"};
       qualityTerminator = new SingleObjectiveQualityTerminator {Name = "Quality"};
       executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
@@ -432,7 +361,9 @@
       globalEvaluatedSolutionsCounter.Successor = resultsCollector;
       resultsCollector.Successor = mainLoop;
-      
+
       #endregion
+
       #region parametrize
+
       ParameterizeAnalyzers();
       UpdateAnalyzers();
@@ -441,7 +372,53 @@
       ParameterizeAgeLimits();
       ParametrizeMigration();
+
       #endregion
 
       InitializeEventHandler();
+    }
+
+    private void AddParameters() {
+      #region ALPSParameter
+
+      Parameters.Add(new ValueParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers.", new IntValue(5)));
+      Parameters.Add(new ValueParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent.", new DoubleValue(1)));
+      Parameters.Add(new ValueParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer.", new IntArray(new int[0])) {Hidden = true});
+      Parameters.Add(new ValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
+      Parameters.Add(new ValueParameter<BoolValue>("ReduceToPopulationSize", ".", new BoolValue(true)));
+
+      Parameters.Add(new ValueParameter<IntValue>("NumberOfLayers", "", new IntValue(100000)));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("GroupAnalyzer", "The operator used to analyze each layergroup.", new MultiAnalyzer()));
+      Parameters.Add(new ValueParameter<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation.", new BoolValue(false)));
+
+      #endregion
+
+      #region IslandParameter
+
+      Parameters.Add(new ValueParameter<IntValue>("NumberOfIslands", "The number of islands.", new IntValue(5)));
+      Parameters.Add(new ValueParameter<PercentValue>("MigrationRate", "How many individuals should migrate.", new PercentValue(0.15)));
+      Parameters.Add(new ValueParameter<IntValue>("MigrationInterval", "The number Generations before a migration occurs.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer()));
+      Parameters.Add(new ConstrainedValueParameter<IMigrator>("Migrator", "The migration strategy."));
+      Parameters.Add(new ConstrainedValueParameter<ISelector>("EmigrantsSelector", "Selects the individuals that will be migrated."));
+      Parameters.Add(new ConstrainedValueParameter<IReplacer>("ImmigrationReplacer", "Selects the population from the unification of the original population and the immigrants."));
+
+      #endregion
+
+      #region GeneralParameter   
+
+      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
+      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
+      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
+      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) {Hidden = true});
+      Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
+
+      #endregion
     }
 
@@ -546,7 +523,7 @@
 
       //add analyzer
-      GroupAnalyzer.Operators.Add(groupQualityAnalyzer, groupQualityAnalyzer.EnabledByDefault);
-      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, layerQualityAnalyzer.EnabledByDefault);
-      IslandAnalyzer.Operators.Add(islandQualityAnalyzer, islandQualityAnalyzer.EnabledByDefault);
+      GroupAnalyzer.Operators.Add(groupQualityAnalyzer, false);
+      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, false);
+      IslandAnalyzer.Operators.Add(islandQualityAnalyzer, false);
       Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
       //depth for each analyzer gets set when added
@@ -554,7 +531,7 @@
         foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
           Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
-          IslandAnalyzer.Operators.Add((IAnalyzer)analyzer.Clone(),false);
-          LayerAnalyzer.Operators.Add((IAnalyzer)analyzer.Clone(), false);
-          GroupAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(),false);
+          IslandAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
+          LayerAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
+          GroupAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
         }
       }
@@ -583,5 +560,5 @@
         foreach (var terminator in Problem.Operators.OfType<ITerminator>())
           newTerminators.Add(terminator,
-            !Terminators.Operators.Contains(terminator) || Terminators.Operators.ItemChecked(terminator));
+                             !Terminators.Operators.Contains(terminator) || Terminators.Operators.ItemChecked(terminator));
       }
 
@@ -600,5 +577,5 @@
       MigrationRateParameter.ValueChanged += MigrationRate_ValueChanged;
 
-      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded; 
+      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded;
       IslandAnalyzer.Operators.ItemsAdded += IslandAnalyzerOperators_ItemsAdded;
       LayerAnalyzer.Operators.ItemsAdded += LayerAnalyzerOperators_ItemsAdded;
@@ -616,9 +593,8 @@
       NumberOfLayersParameter.ValueChanged += NumberOfLayersParameter_ValueChanged;
       NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
-
     }
 
     private void MigrationRate_ValueChanged(object sender, EventArgs e) {
-      var migrationSize = (int)Math.Ceiling(MigrationRateParameter.Value.Value * PopulationSize.Value);
+      var migrationSize = (int) Math.Ceiling(MigrationRateParameter.Value.Value*PopulationSize.Value);
       foreach (var selector in EmigrantsSelectorParameter.ValidValues) {
         selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(migrationSize);
@@ -653,4 +629,5 @@
       }
     }
+
     private void LayerAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
       foreach (var analyzer in e.Items) {
@@ -684,31 +661,40 @@
       ParameterizeSelectors();
     }
+
     private void Elites_ValueChanged(object sender, EventArgs e) {
       ParameterizeSelectors();
     }
+
     private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
       ParameterizeSelectors();
     }
+
     private void PopulationSize_ValueChanged(object sender, EventArgs e) {
       ParameterizeSelectors();
     }
+
     private void NumberOfLayersParameter_ValueChanged(object sender, EventArgs e) {
       NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
       ParameterizeAgeLimits();
     }
+
     private void NumberOfLayers_ValueChanged(object sender, EventArgs e) {
       ParameterizeAgeLimits();
     }
+
     private void AgeGapParameter_ValueChanged(object sender, EventArgs e) {
       AgeGap.ValueChanged += AgeGap_ValueChanged;
       ParameterizeAgeLimits();
     }
+
     private void AgeGap_ValueChanged(object sender, EventArgs e) {
       ParameterizeAgeLimits();
     }
+
     private void AgingSchemeParameter_ValueChanged(object sender, EventArgs e) {
       AgingScheme.ValueChanged += AgingScheme_ValueChanged;
       ParameterizeAgeLimits();
     }
+
     private void AgingScheme_ValueChanged(object sender, EventArgs e) {
       ParameterizeAgeLimits();
@@ -717,11 +703,10 @@
     private void ParameterizeAgeLimits() {
       var scheme = AgingScheme.Value;
-      int ageGap = AgeGap.Value;
-      int numberOfLayers = NumberOfLayers.Value;
+      var ageGap = AgeGap.Value;
+      var numberOfLayers = NumberOfLayers.Value;
       AgeLimits = scheme.CalculateAgeLimits(ageGap, numberOfLayers);
     }
 
     private void ParameterizeMainLoop() {
-      //TODO
       MainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
       MainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
@@ -744,6 +729,4 @@
       MainLoop.ImmigrationReplacerParameter.ActualName = ImmigrationReplacerParameter.Name;
 
-
-
       MainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
       MainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
@@ -766,6 +749,6 @@
 
     private void ParametrizeMigration() {
-      var migrationSize = (int) Math.Ceiling(MigrationRateParameter.Value.Value *PopulationSize.Value);
-      foreach (ISelector selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name)) {
+      var migrationSize = (int) Math.Ceiling(MigrationRateParameter.Value.Value*PopulationSize.Value);
+      foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name)) {
         selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(migrationSize);
         selector.NumberOfSelectedSubScopesParameter.Hidden = true;
@@ -776,5 +759,5 @@
       }
 
-      foreach (IReplacer replacer in ApplicationManager.Manager.GetInstances<IReplacer>().OrderBy(x => x.Name)) {
+      foreach (var replacer in ApplicationManager.Manager.GetInstances<IReplacer>().OrderBy(x => x.Name)) {
         ParameterizeStochasticOperatorForLayer(replacer);
         ImmigrationReplacerParameter.ValidValues.Add(replacer);
@@ -807,5 +790,4 @@
           ParametrizeSingleObjectiveSelector(selector);
         }
-
       }
     }
Index: anches/IslandALPS/IslandALPS/3.3/IslandALPSAlgorthmsMainLoop.cs
===================================================================
--- /branches/IslandALPS/IslandALPS/3.3/IslandALPSAlgorthmsMainLoop.cs	(revision 13685)
+++ 	(revision )
@@ -1,583 +1,0 @@
-﻿using HeuristicLab.Algorithms.ALPS;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Optimization.Operators;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Selection;
-
-namespace HeuristicLab.Algorithms.IslandALPS {
-  [Item("IslandALPSAlgorithmMainLoop", "An island ALPS main loop operator.")]
-  [StorableClass]
-  public class IslandAlpsAlgorthmsMainLoop : AlgorithmOperator{
-
-    [StorableConstructor]
-    private IslandAlpsAlgorthmsMainLoop(bool deserializing) : base(deserializing) { }
-
-    #region Parameter Properties
-    public ValueLookupParameter<IRandom> GlobalRandomParameter {
-      get { return (ValueLookupParameter<IRandom>)Parameters["GlobalRandom"]; }
-    }
-    public ValueLookupParameter<IRandom> IslandRandomParameter {
-      get { return (ValueLookupParameter<IRandom>)Parameters["IslandRandom"]; }
-    }
-    public ValueLookupParameter<IRandom> LayerRandomParameter {
-      get { return (ValueLookupParameter<IRandom>)Parameters["LayerRandom"]; }
-    }
-
-    public ValueLookupParameter<BoolValue> MaximizationParameter {
-      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
-    }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-    public ValueLookupParameter<DoubleValue> BestKnownQualityParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
-    }
-    
-    public ValueLookupParameter<IntValue> PopulationSizeParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["PopulationSize"]; }
-    }
-
-    public ValueLookupParameter<IOperator> SelectorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["Selector"]; }
-    }
-    public ValueLookupParameter<IOperator> CrossoverParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["Crossover"]; }
-    }
-    public ValueLookupParameter<PercentValue> MutationProbabilityParameter {
-      get { return (ValueLookupParameter<PercentValue>)Parameters["MutationProbability"]; }
-    }
-    public ValueLookupParameter<IOperator> MutatorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["Mutator"]; }
-    }
-    public ValueLookupParameter<IOperator> EvaluatorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
-    }
-    public ValueLookupParameter<IntValue> ElitesParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
-    }
-    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
-      get { return (IValueLookupParameter<BoolValue>)Parameters["ReevaluateElites"]; }
-    }
-    public ValueLookupParameter<ResultCollection> ResultsParameter {
-      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
-    }
-    public ILookupParameter<ITerminator> TerminatorParameter {
-      get { return (ILookupParameter<ITerminator>)Parameters["Terminator"]; }
-    }
-
-    public ValueLookupParameter<IOperator> AnalyzerParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
-    }
-    public ValueLookupParameter<IOperator> IslandAnalyzerParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["IslandAnalyzer"]; }
-    }
-    public ValueLookupParameter<IOperator> LayerAnalyzerParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["LayerAnalyzer"]; }
-    }
-
-    public ValueLookupParameter<IOperator> GroupAnalyzerParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["GroupAnalyzer"]; }
-    }
-
-    public LookupParameter<IntValue> LayerEvaluatedSolutionsParameter {
-      get { return (LookupParameter<IntValue>)Parameters["LayerEvaluatedSolutions"]; }
-    }
-    public LookupParameter<IntValue> EvaluatedSolutions {
-      get { return (LookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
-    }
-    #region island
-    public ValueLookupParameter<IntValue> NumberOfIslandsParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["NumberOfIslands"]; }
-    }
-    public ValueLookupParameter<IntValue> MigrationIntervalParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["MigrationInterval"]; }
-    }
-    public ValueLookupParameter<PercentValue> MigrationRateParameter {
-      get { return (ValueLookupParameter<PercentValue>)Parameters["MigrationRate"]; }
-    }
-    public ValueLookupParameter<IOperator> MigratorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["Migrator"]; }
-    }
-    public ValueLookupParameter<IOperator> EmigrantsSelectorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["EmigrantsSelector"]; }
-    }
-    public ValueLookupParameter<IOperator> ImmigrationReplacerParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["ImmigrationReplacer"]; }
-    }
-    public ValueLookupParameter<BoolValue> Migrate {
-      get { return (ValueLookupParameter<BoolValue>)Parameters["Migrate"]; }
-    }
-    public LookupParameter<IntValue> IslandEvaluatedSolutions {
-      get { return (LookupParameter<IntValue>)Parameters["IslandEvaluatedSolutions"]; }
-    }
-
-    #endregion
-
-    #region alps
-    public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["CurrentPopulationSize"]; }
-    }
-    public IValueLookupParameter<IntValue> NumberOfLayersParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["NumberOfLayers"]; }
-    }
-    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
-      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
-    }
-    public IValueLookupParameter<IntValue> AgeGapParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["AgeGap"]; }
-    }
-    public IValueLookupParameter<DoubleValue> AgeInheritanceParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["AgeInheritance"]; }
-    }
-    public IValueLookupParameter<IntArray> AgeLimitsParameter {
-      get { return (IValueLookupParameter<IntArray>)Parameters["AgeLimits"]; }
-    }
-    public IValueLookupParameter<IntValue> MatingPoolRangeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MatingPoolRange"]; }
-    }
-    public IValueLookupParameter<BoolValue> ReduceToPopulationSizeParameter {
-      get { return (IValueLookupParameter<BoolValue>)Parameters["ReduceToPopulationSize"]; }
-    }
-    public IValueLookupParameter<BoolValue> PlusSelectionParameter {
-      get { return (IValueLookupParameter<BoolValue>)Parameters["PlusSelection"]; }
-    }
-    #endregion
-
-    #endregion
-
-    private IslandAlpsAlgorthmsMainLoop(IslandAlpsAlgorthmsMainLoop original, Cloner cloner) :
-      base(original,cloner){ }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new IslandAlpsAlgorthmsMainLoop(this,cloner);
-    }
-
-    public IslandAlpsAlgorthmsMainLoop() : base() {
-
-      #region Create parameters
-      Parameters.Add(new ValueLookupParameter<IRandom>("GlobalRandom", "A pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<IRandom>("IslandRandom", "A pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<IRandom>("LayerRandom", "A pseudo random number generator."));
-
-      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
-
-      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfLayers", "The number of Layers per Island."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfIslands", "The number of islands."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MigrationInterval", "The number of generations that should pass between migration phases."));
-      Parameters.Add(new ValueLookupParameter<PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("Migrator", "The migration strategy."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("EmigrantsSelector", "Selects the individuals that will be migrated."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("ImmigrationReplacer", "Replaces some of the original population with the immigrants."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("CurrentPopulationSize", "The current size of the population of solutions."));
-
-      Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
-      Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
-      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
-      Parameters.Add(new ValueLookupParameter<ITerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop"));
-
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The age of individuals."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent."));
-      Parameters.Add(new ValueLookupParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer."));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MatingPoolRange", "The range of sub - populations used for creating a mating pool. (1 = current + previous sub-population)"));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize"));
-
-      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the islands."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("IslandAnalyzer", "The operator used to analyze each island."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("LayerAnalyzer", "The operator used to analyze each Layer."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("GroupAnalyzer", "The operator used to analyze each Layergroup."));
-
-      Parameters.Add(new LookupParameter<IntValue>("LayerEvaluatedSolutions", "The number of times a solution has been evaluated."));
-      //TODO: make long ?
-      Parameters.Add(new LookupParameter<IntValue>("IslandEvaluatedSolutions", "The number of times a solution has been evaluated on one island."));
-      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times a solution has been evaluated on one island."));
-
-      Parameters.Add(new ValueLookupParameter<BoolValue>("Migrate", "Migrate the island?"));
-
-      #endregion
-      var globalVariableCreator = new VariableCreator() { Name = "Create global values" };
-      var islandVarCreatorUssp = new UniformSubScopesProcessor();
-      var islandVariableCreator = new VariableCreator() {Name = "Initialize Results"};
-      var groupVariableCreator = new VariableCreator() {Name = "Initialize Group Results"};
-
-      var layerUssp = new UniformSubScopesProcessor();
-      var layerVariableCreator = new VariableCreator() {};
-
-      var initLayerAnalyzerPlaceholder = new Placeholder() {Name = "Layer Analyzer (Placeholder)"};
-      var initIslandAnalyzerPlaceholder = new Placeholder() {Name = "Island Analyzer (Placeholder)"};
-      var initGlobalAnalyzerPlacerholder =new Placeholder() {Name = "Global Analyzer (Placeholder)"};
-      var resultsCollector = new ResultsCollector();
-
-      var processIslandsUssp = new UniformSubScopesProcessor() {Name = "Process Islands", Parallel = new BoolValue(true)};
-      var initIslandEvaluationsAss = new Assigner() {Name = "Init Island Evaluations"};
-
-      var incrementGenerationDr = new IntCounter() { Name = "Increment Generations" };
-      var incrementEvaluatedSolutionDr = new DataReducer() { Name = "Increment Evaluated Solutions" };
-
-      var elderMigrator = CreateEldersEmigrator();
-      var newLayerOpener = CreateLayerOpener();
-      var reseeder = CreateReseeder();
-
-      var analyzeLayerUssp = new UniformSubScopesProcessor();
-
-      var layerAnalyzerPlaceholder = new Placeholder() { Name = "Layer Analyzer (Placeholder)" };
-      var layerResultsCollector = new ResultsCollector() {Name = "Collect Additional Infos"};
-      var islandAnalyzerPlaceholder = new Placeholder() { Name = "Island Analyzer (Placeholder)" };
-      var islandResultsCollector = new ResultsCollector() { Name = "Collect layer results into IslandResults" };
-
-      var globalAnalyzerPlacerholder = new Placeholder() { Name = "Global Analyzer (Placeholder)" };
-
-      var groupingOperator = new GroupedLayerOperator() {Name = "Grouped Analyzer"};
-      var groupAnalyzer = new Placeholder() {Name = "Group Analyzer (Placeholder)"};
-      var groupResultsExtractor = new ResultsExtractor() {Name = "Collect group results into variable"};
-      var groupResultsCollector = new ResultsCollector() {Name = "Collect group results into into global results"};
-      var groupLayerNumberResultsCollector = new ResultsCollector() {Name = "Add Layernumber to Results"};
-
-      var matingPoolCreator = new MatingPoolCreator();
-      var matingPoolUssp = new UniformSubScopesProcessor() {Name = "Process Mating Pools"};
-      var alpsMainOperator = new AlpsGeneticAlgorithmMainOperator();
-
-      var setIslandEvaluatedSolutions = new DataReducer() {Name = "Set IslandEvaluatedSolutions" };
-
-      var migrationThresholdCounter = new IntCounter() {Name = "Increment Counter for Migrations"};
-      var migrationThresholdAss = new Assigner() {Name = "Reset Counter for Migrations"};
-      var migrationCounter = new IntCounter() {Name = "Increment  Migrations"};
-      var selectforMigrationUssp = new UniformSubScopesProcessor();
-      var emigrantSelector = new Placeholder() {Name = "Emigrant Selector (Placeholder)"};
-      var migrator = new LayerMigrator();
-      var replaceforMigrationUssp = new UniformSubScopesProcessor();
-      var immigrantSelector = new Placeholder() { Name = "Immigrant Replacer (Placeholder)" };
-
-      var migrateComparator = new Comparator();
-      var migrateCondBranch = new ConditionalBranch() {Name = "Migrate?"};
-
-      var terminator = new TerminationOperator();
-      
-      globalVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations",new IntValue(0)));
-      globalVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Migrations",new IntValue(0)));
-
-      islandVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OpenLayers", new IntValue(1)));
-      islandVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("IslandResults"));
-
-      layerVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Layer", new IntValue(0)));
-      layerVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("LayerResults"));
-
-      groupVariableCreator.CollectedValues.Add((new ValueParameter<ResultCollection>("GroupResults")));
-      //TODO: groupAnalyze
-      initLayerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
-      initIslandAnalyzerPlaceholder.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
-      initGlobalAnalyzerPlacerholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
-
-      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
-      resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("IslandResults","","IslandResults"));
-      resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("GroupResults","","GroupResults"));
-      resultsCollector.CollectedValues.Add(new ValueLookupParameter<IntValue>("Migrations"));
-      resultsCollector.CopyValue = new BoolValue(false);
-
-      initIslandEvaluationsAss.LeftSideParameter.ActualName = IslandEvaluatedSolutions.Name;
-      initIslandEvaluationsAss.RightSideParameter.Value = new IntValue(0);
-
-      incrementGenerationDr.ValueParameter.ActualName = "Generations";
-
-      incrementEvaluatedSolutionDr.ParameterToReduce.ActualName = IslandEvaluatedSolutions.Name;
-      incrementEvaluatedSolutionDr.TargetParameter.ActualName = EvaluatedSolutions.Name;
-      incrementEvaluatedSolutionDr.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
-      incrementEvaluatedSolutionDr.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
-
-      setIslandEvaluatedSolutions.ParameterToReduce.ActualName = LayerEvaluatedSolutionsParameter.Name;
-      setIslandEvaluatedSolutions.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
-      setIslandEvaluatedSolutions.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
-      setIslandEvaluatedSolutions.TargetParameter.ActualName = IslandEvaluatedSolutions.Name;
-
-
-      migrationThresholdCounter.ValueParameter.ActualName = "MigrationThreshold";
-      
-      migrateComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
-      migrateComparator.LeftSideParameter.ActualName = "MigrationThreshold";
-      migrateComparator.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
-      migrateComparator.ResultParameter.ActualName = "Migrate";
-
-      migrateCondBranch.ConditionParameter.ActualName = "Migrate";
-
-      migrationCounter.ValueParameter.ActualName = "Migrations";
-      migrationThresholdAss.LeftSideParameter.ActualName = "MigrationThreshold";
-      migrationThresholdAss.RightSideParameter.Value = new IntValue(0);
-
-      selectforMigrationUssp.Depth = new IntValue(2);
-      emigrantSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
-
-      replaceforMigrationUssp.Depth = new IntValue(2);
-      immigrantSelector.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
-
-      groupAnalyzer.OperatorParameter.ActualName = GroupAnalyzerParameter.Name;
-      groupLayerNumberResultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("LayerNumber"));
-      groupLayerNumberResultsCollector.ResultsParameter.ActualName = "GroupResults";
-
-      layerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
-      layerResultsCollector.ResultsParameter.ActualName = "LayerResults";
-      layerResultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Layer"));
-      islandAnalyzerPlaceholder.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
-      islandResultsCollector.ResultsParameter.ActualName = "IslandResults";
-      islandResultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("LayerResults"));
-      globalAnalyzerPlacerholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
-
-      //TODO: implement check for grouped layer analyzer
-      groupResultsExtractor.SourceNameParameter.Value = new StringValue("GroupScope");
-      groupResultsExtractor.TargetNameParameter.Value = new StringValue("GroupResults");
-      groupResultsCollector.CollectedValues.Add(new LookupParameter<ItemArray<ResultCollection>>("GroupResults"));
-      matingPoolCreator.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name; 
-
-      alpsMainOperator.RandomParameter.ActualName = LayerRandomParameter.Name;
-      alpsMainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
-      alpsMainOperator.EvaluatedSolutionsParameter.ActualName = LayerEvaluatedSolutionsParameter.Name;
-      alpsMainOperator.QualityParameter.ActualName = QualityParameter.Name;
-      alpsMainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      alpsMainOperator.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
-      alpsMainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
-      alpsMainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
-      alpsMainOperator.MutatorParameter.ActualName = MutatorParameter.ActualName;
-      alpsMainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
-      alpsMainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
-      alpsMainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
-      alpsMainOperator.PlusSelectionParameter.ActualName = PlusSelectionParameter.Name;
-      alpsMainOperator.AgeParameter.ActualName = AgeParameter.Name;
-      alpsMainOperator.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
-      alpsMainOperator.AgeIncrementParameter.Value = new DoubleValue(1.0);
-
-      //flow
-      OperatorGraph.InitialOperator = globalVariableCreator;
-      globalVariableCreator.Successor = islandVarCreatorUssp;
-      islandVarCreatorUssp.Operator = islandVariableCreator;
-      islandVariableCreator.Successor = layerUssp;
-      layerUssp.Operator = layerVariableCreator;
-      layerVariableCreator.Successor = initLayerAnalyzerPlaceholder;
-      initLayerAnalyzerPlaceholder.Successor = null;
-      layerUssp.Successor = initIslandAnalyzerPlaceholder;
-      initLayerAnalyzerPlaceholder.Successor = null;
-      islandVarCreatorUssp.Successor = initGlobalAnalyzerPlacerholder;
-      initGlobalAnalyzerPlacerholder.Successor = resultsCollector;
-      resultsCollector.Successor = processIslandsUssp;
-      processIslandsUssp.Operator = initIslandEvaluationsAss;
-      initIslandEvaluationsAss.Successor = matingPoolCreator;
-      matingPoolCreator.Successor = matingPoolUssp;
-      matingPoolUssp.Operator = alpsMainOperator;
-      alpsMainOperator.Successor = null;
-      matingPoolUssp.Successor = elderMigrator;
-      elderMigrator.Successor = newLayerOpener;
-      newLayerOpener.Successor = reseeder;
-      reseeder.Successor = analyzeLayerUssp;
-      analyzeLayerUssp.Operator = layerAnalyzerPlaceholder;
-      layerAnalyzerPlaceholder.Successor = layerResultsCollector;
-      layerResultsCollector.Successor = null;
-
-      analyzeLayerUssp.Successor = islandAnalyzerPlaceholder;
-      islandAnalyzerPlaceholder.Successor = islandResultsCollector;
-      islandResultsCollector.Successor = setIslandEvaluatedSolutions;
-      setIslandEvaluatedSolutions.Successor = null;
-
-      processIslandsUssp.Successor = incrementGenerationDr;
-      incrementGenerationDr.Successor = incrementEvaluatedSolutionDr;
-      incrementEvaluatedSolutionDr.Successor = migrationThresholdCounter;
-
-      migrationThresholdCounter.Successor = migrateComparator;
-
-      migrateComparator.Successor = migrateCondBranch;
-      migrateCondBranch.FalseBranch = null;
-      migrateCondBranch.TrueBranch = migrationThresholdAss;
-      migrationThresholdAss.Successor = migrationCounter;
-
-      migrationCounter.Successor = selectforMigrationUssp;
-      selectforMigrationUssp.Operator = emigrantSelector;
-      emigrantSelector.Successor = null;
-      selectforMigrationUssp.Successor = migrator;
-
-      migrator.Successor = replaceforMigrationUssp;
-      replaceforMigrationUssp.Operator = immigrantSelector;
-      immigrantSelector.Successor = null;
-      replaceforMigrationUssp.Successor = null;
-
-      migrateCondBranch.Successor = globalAnalyzerPlacerholder;
-
-
-      globalAnalyzerPlacerholder.Successor = groupingOperator;
-      groupingOperator.Operator = groupAnalyzer;
-      groupAnalyzer.Successor = groupLayerNumberResultsCollector;
-      groupLayerNumberResultsCollector.Successor = null;
-      groupingOperator.Successor = groupResultsExtractor;
-      groupResultsExtractor.Successor = groupResultsCollector;
-      groupResultsCollector.Successor = terminator;
-      terminator.ContinueBranch = processIslandsUssp;
-
-    }
-
-    private CombinedOperator CreateEldersEmigrator() {
-      var eldersEmigrator = new CombinedOperator() { Name = "Emigrate Elders" };
-      var selectorProsessor = new UniformSubScopesProcessor();
-      var eldersSelector = new EldersSelector();
-      var shiftToRightMigrator = new UnidirectionalRingMigrator() { Name = "Shift elders to next layer" };
-      var mergingProsessor = new UniformSubScopesProcessor();
-      var mergingReducer = new MergingReducer();
-      var subScopesCounter = new SubScopesCounter();
-      var reduceToPopulationSizeBranch = new ConditionalBranch() { Name = "ReduceToPopulationSize?" };
-      var countCalculator = new ExpressionCalculator() { Name = "CurrentPopulationSize = Min(CurrentPopulationSize, PopulationSize)" };
-      var bestSelector = new BestSelector();
-      var rightReducer = new RightReducer();
-
-      eldersEmigrator.OperatorGraph.InitialOperator = selectorProsessor;
-
-      selectorProsessor.Operator = eldersSelector;
-      selectorProsessor.Successor = shiftToRightMigrator;
-
-      eldersSelector.AgeParameter.ActualName = AgeParameter.Name;
-      eldersSelector.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
-      eldersSelector.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
-      eldersSelector.LayerParameter.ActualName = "Layer";
-      eldersSelector.Successor = null;
-
-      shiftToRightMigrator.ClockwiseMigrationParameter.Value = new BoolValue(true);
-      shiftToRightMigrator.Successor = mergingProsessor;
-
-      mergingProsessor.Operator = mergingReducer;
-
-      mergingReducer.Successor = subScopesCounter;
-
-      subScopesCounter.ValueParameter.ActualName = CurrentPopulationSizeParameter.Name;
-      subScopesCounter.AccumulateParameter.Value = new BoolValue(false);
-      subScopesCounter.Successor = reduceToPopulationSizeBranch;
-
-      reduceToPopulationSizeBranch.ConditionParameter.ActualName = ReduceToPopulationSizeParameter.Name;
-      reduceToPopulationSizeBranch.TrueBranch = countCalculator;
-
-      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>(PopulationSizeParameter.Name));
-      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>(CurrentPopulationSizeParameter.Name));
-      countCalculator.ExpressionParameter.Value = new StringValue("CurrentPopulationSize PopulationSize CurrentPopulationSize PopulationSize < if toint");
-      countCalculator.ExpressionResultParameter.ActualName = CurrentPopulationSizeParameter.Name;
-      countCalculator.Successor = bestSelector;
-
-      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = CurrentPopulationSizeParameter.Name;
-      bestSelector.CopySelected = new BoolValue(false);
-      bestSelector.Successor = rightReducer;
-
-      return eldersEmigrator;
-    }
-
-    private CombinedOperator CreateLayerOpener() {
-      var layerOpener = new CombinedOperator() { Name = "Open new Layer if needed" };
-      var maxLayerReached = new Comparator() { Name = "MaxLayersReached = OpenLayers >= NumberOfLayers" };
-      var maxLayerReachedBranch = new ConditionalBranch() { Name = "MaxLayersReached?" };
-      var openNewLayerCalculator = new ExpressionCalculator() { Name = "OpenNewLayer = Generations >= AgeLimits[OpenLayers - 1]" };
-      var openNewLayerBranch = new ConditionalBranch() { Name = "OpenNewLayer?" };
-      var layerCreator = new LastLayerCloner() { Name = "Create Layer" };
-      var updateLayerNumber = new Assigner() { Name = "Layer = OpenLayers" };
-      var historyWiper = new ResultsHistoryWiper() { Name = "Clear History in Results" };
-      var createChildrenViaCrossover = new AlpsGeneticAlgorithmMainOperator();
-      var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
-      var incrOpenLayers = new IntCounter() { Name = "Incr. OpenLayers" };
-      //var newLayerResultsCollector = new ResultsCollector() { Name = "Collect new Layer Results" };
-
-      layerOpener.OperatorGraph.InitialOperator = maxLayerReached;
-
-      maxLayerReached.LeftSideParameter.ActualName = "OpenLayers";
-      maxLayerReached.RightSideParameter.ActualName = NumberOfLayersParameter.Name;
-      maxLayerReached.ResultParameter.ActualName = "MaxLayerReached";
-      maxLayerReached.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
-      maxLayerReached.Successor = maxLayerReachedBranch;
-
-      maxLayerReachedBranch.ConditionParameter.ActualName = "MaxLayerReached";
-      maxLayerReachedBranch.FalseBranch = openNewLayerCalculator;
-
-      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntArray>(AgeLimitsParameter.Name));
-      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
-      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>(NumberOfLayersParameter.Name));
-      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("OpenLayers"));
-      openNewLayerCalculator.ExpressionResultParameter.ActualName = "OpenNewLayer";
-      openNewLayerCalculator.ExpressionParameter.Value = new StringValue("Generations 1 + AgeLimits OpenLayers 1 - [] >");
-      openNewLayerCalculator.Successor = openNewLayerBranch;
-
-      openNewLayerBranch.ConditionParameter.ActualName = "OpenNewLayer";
-      openNewLayerBranch.TrueBranch = layerCreator;
-
-      layerCreator.NewLayerOperator = updateLayerNumber;
-      layerCreator.Successor = incrOpenLayers;
-
-      updateLayerNumber.LeftSideParameter.ActualName = "Layer";
-      updateLayerNumber.RightSideParameter.ActualName = "OpenLayers";
-      updateLayerNumber.Successor = historyWiper;
-
-      historyWiper.ResultsParameter.ActualName = "LayerResults";
-      historyWiper.Successor = createChildrenViaCrossover;
-
-      // Maybe use only crossover and no elitism instead of "default operator"
-      createChildrenViaCrossover.RandomParameter.ActualName = LayerRandomParameter.Name;
-      createChildrenViaCrossover.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
-      createChildrenViaCrossover.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
-      createChildrenViaCrossover.QualityParameter.ActualName = QualityParameter.Name;
-      createChildrenViaCrossover.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      createChildrenViaCrossover.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
-      createChildrenViaCrossover.SelectorParameter.ActualName = SelectorParameter.Name;
-      createChildrenViaCrossover.CrossoverParameter.ActualName = CrossoverParameter.Name;
-      createChildrenViaCrossover.MutatorParameter.ActualName = MutatorParameter.Name;
-      createChildrenViaCrossover.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
-      createChildrenViaCrossover.ElitesParameter.ActualName = ElitesParameter.Name;
-      createChildrenViaCrossover.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
-      createChildrenViaCrossover.PlusSelectionParameter.ActualName = PlusSelectionParameter.Name;
-      createChildrenViaCrossover.AgeParameter.ActualName = AgeParameter.Name;
-      createChildrenViaCrossover.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
-      createChildrenViaCrossover.AgeIncrementParameter.Value = new DoubleValue(0.0);
-      createChildrenViaCrossover.Successor = incrEvaluatedSolutionsForNewLayer;
-
-      incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = LayerEvaluatedSolutionsParameter.Name;
-      incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
-
-      incrOpenLayers.ValueParameter.ActualName = "OpenLayers";
-      incrOpenLayers.Increment = new IntValue(1);
-
-      return layerOpener;
-    }
-
-    private CombinedOperator CreateReseeder() {
-      var reseeder = new CombinedOperator() { Name = "Reseed Layer Zero if needed" };
-      var reseedingController = new ReseedingController() { Name = "Reseeding needed (Generation % AgeGap == 0)?" };
-      var removeIndividuals = new SubScopesRemover();
-      var createIndividuals = new SolutionsCreator();
-      var initializeAgeProsessor = new UniformSubScopesProcessor();
-      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
-      var incrEvaluatedSolutionsAfterReseeding = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
-
-      reseeder.OperatorGraph.InitialOperator = reseedingController;
-
-      reseedingController.GenerationsParameter.ActualName = "Generations";
-      reseedingController.AgeGapParameter.ActualName = AgeGapParameter.Name;
-      reseedingController.FirstLayerOperator = removeIndividuals;
-      reseedingController.Successor = null;
-
-      removeIndividuals.Successor = createIndividuals;
-
-      createIndividuals.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
-      createIndividuals.Successor = initializeAgeProsessor;
-
-      initializeAgeProsessor.Operator = initializeAge;
-      initializeAgeProsessor.Successor = incrEvaluatedSolutionsAfterReseeding;
-
-      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>(AgeParameter.Name, new DoubleValue(0)));
-
-      incrEvaluatedSolutionsAfterReseeding.ValueParameter.ActualName = LayerEvaluatedSolutionsParameter.Name;
-      incrEvaluatedSolutionsAfterReseeding.AccumulateParameter.Value = new BoolValue(true);
-
-      return reseeder;
-    }
-  }
-}
Index: /branches/IslandALPS/IslandALPS/3.3/IslandAlpsAlgorithmMainLoop.cs
===================================================================
--- /branches/IslandALPS/IslandALPS/3.3/IslandAlpsAlgorithmMainLoop.cs	(revision 13686)
+++ /branches/IslandALPS/IslandALPS/3.3/IslandAlpsAlgorithmMainLoop.cs	(revision 13686)
@@ -0,0 +1,633 @@
+﻿using HeuristicLab.Algorithms.ALPS;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.IslandALPS {
+  [Item("IslandALPSAlgorithmMainLoop", "An island ALPS main loop operator.")]
+  [StorableClass]
+  public class IslandAlpsAlgorithmMainLoop : AlgorithmOperator {
+    private const string LayerResultsParametername = "LayerResults";
+    private const string GenerationsParametername = "Generations";
+    private const string IslandResultsParametername = "IslandResults";
+    private const string LayerParametername = "Layer";
+    private const string MigrationsParametername = "Migrations";
+    private const string OpenLayersParametername = "OpenLayers";
+    private const string GroupResultsParametername = "GroupResults";
+    private const string MigrationThresholdParametername = "MigrationThreshold";
+    private const string MigrateParametername = "Migrate";
+    private const string LayerEvaluatedSolutionsParameterName = "LayerEvaluatedSolutions";
+
+    [StorableConstructor]
+    private IslandAlpsAlgorithmMainLoop(bool deserializing) : base(deserializing) {}
+
+    #region Parameter Properties
+
+    public ValueLookupParameter<IRandom> GlobalRandomParameter {
+      get { return (ValueLookupParameter<IRandom>) Parameters["GlobalRandom"]; }
+    }
+
+    public ValueLookupParameter<IRandom> IslandRandomParameter {
+      get { return (ValueLookupParameter<IRandom>) Parameters["IslandRandom"]; }
+    }
+
+    public ValueLookupParameter<IRandom> LayerRandomParameter {
+      get { return (ValueLookupParameter<IRandom>) Parameters["LayerRandom"]; }
+    }
+
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>) Parameters["Maximization"]; }
+    }
+
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>) Parameters["Quality"]; }
+    }
+
+    public ValueLookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ValueLookupParameter<DoubleValue>) Parameters["BestKnownQuality"]; }
+    }
+
+    public ValueLookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ValueLookupParameter<IntValue>) Parameters["PopulationSize"]; }
+    }
+
+    public ValueLookupParameter<IOperator> SelectorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Selector"]; }
+    }
+
+    public ValueLookupParameter<IOperator> CrossoverParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Crossover"]; }
+    }
+
+    public ValueLookupParameter<PercentValue> MutationProbabilityParameter {
+      get { return (ValueLookupParameter<PercentValue>) Parameters["MutationProbability"]; }
+    }
+
+    public ValueLookupParameter<IOperator> MutatorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Mutator"]; }
+    }
+
+    public ValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Evaluator"]; }
+    }
+
+    public ValueLookupParameter<IntValue> ElitesParameter {
+      get { return (ValueLookupParameter<IntValue>) Parameters["Elites"]; }
+    }
+
+    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
+      get { return (IValueLookupParameter<BoolValue>) Parameters["ReevaluateElites"]; }
+    }
+
+    public ValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (ValueLookupParameter<ResultCollection>) Parameters["Results"]; }
+    }
+
+    public ILookupParameter<ITerminator> TerminatorParameter {
+      get { return (ILookupParameter<ITerminator>) Parameters["Terminator"]; }
+    }
+
+    public ValueLookupParameter<IOperator> AnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Analyzer"]; }
+    }
+
+    public ValueLookupParameter<IOperator> IslandAnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["IslandAnalyzer"]; }
+    }
+
+    public ValueLookupParameter<IOperator> LayerAnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["LayerAnalyzer"]; }
+    }
+
+    public ValueLookupParameter<IOperator> GroupAnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["GroupAnalyzer"]; }
+    }
+
+    public LookupParameter<IntValue> LayerEvaluatedSolutionsParameter {
+      get { return (LookupParameter<IntValue>) Parameters[LayerEvaluatedSolutionsParameterName]; }
+    }
+
+    public LookupParameter<IntValue> EvaluatedSolutions {
+      get { return (LookupParameter<IntValue>) Parameters["EvaluatedSolutions"]; }
+    }
+
+    #region island
+
+    public ValueLookupParameter<IntValue> NumberOfIslandsParameter {
+      get { return (ValueLookupParameter<IntValue>) Parameters["NumberOfIslands"]; }
+    }
+
+    public ValueLookupParameter<IntValue> MigrationIntervalParameter {
+      get { return (ValueLookupParameter<IntValue>) Parameters["MigrationInterval"]; }
+    }
+
+    public ValueLookupParameter<PercentValue> MigrationRateParameter {
+      get { return (ValueLookupParameter<PercentValue>) Parameters["MigrationRate"]; }
+    }
+
+    public ValueLookupParameter<IOperator> MigratorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Migrator"]; }
+    }
+
+    public ValueLookupParameter<IOperator> EmigrantsSelectorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["EmigrantsSelector"]; }
+    }
+
+    public ValueLookupParameter<IOperator> ImmigrationReplacerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["ImmigrationReplacer"]; }
+    }
+
+    public ValueLookupParameter<BoolValue> Migrate {
+      get { return (ValueLookupParameter<BoolValue>) Parameters[MigrateParametername]; }
+    }
+
+    public LookupParameter<IntValue> IslandEvaluatedSolutions {
+      get { return (LookupParameter<IntValue>) Parameters["IslandEvaluatedSolutions"]; }
+    }
+
+    #endregion
+
+    #region alps
+
+    public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>) Parameters["CurrentPopulationSize"]; }
+    }
+
+    public IValueLookupParameter<IntValue> NumberOfLayersParameter {
+      get { return (IValueLookupParameter<IntValue>) Parameters["NumberOfLayers"]; }
+    }
+
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>) Parameters["Age"]; }
+    }
+
+    public IValueLookupParameter<IntValue> AgeGapParameter {
+      get { return (IValueLookupParameter<IntValue>) Parameters["AgeGap"]; }
+    }
+
+    public IValueLookupParameter<DoubleValue> AgeInheritanceParameter {
+      get { return (IValueLookupParameter<DoubleValue>) Parameters["AgeInheritance"]; }
+    }
+
+    public IValueLookupParameter<IntArray> AgeLimitsParameter {
+      get { return (IValueLookupParameter<IntArray>) Parameters["AgeLimits"]; }
+    }
+
+    public IValueLookupParameter<IntValue> MatingPoolRangeParameter {
+      get { return (IValueLookupParameter<IntValue>) Parameters["MatingPoolRange"]; }
+    }
+
+    public IValueLookupParameter<BoolValue> ReduceToPopulationSizeParameter {
+      get { return (IValueLookupParameter<BoolValue>) Parameters["ReduceToPopulationSize"]; }
+    }
+
+    public IValueLookupParameter<BoolValue> PlusSelectionParameter {
+      get { return (IValueLookupParameter<BoolValue>) Parameters["PlusSelection"]; }
+    }
+
+    #endregion
+
+    #endregion
+
+    private IslandAlpsAlgorithmMainLoop(IslandAlpsAlgorithmMainLoop original, Cloner cloner) :
+      base(original, cloner) {}
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IslandAlpsAlgorithmMainLoop(this, cloner);
+    }
+
+    public IslandAlpsAlgorithmMainLoop() {
+      AddParameters();
+
+      #region create Operators
+
+      var globalVariableCreator = new VariableCreator {Name = "Create global values"};
+      var islandVarCreatorUssp = new UniformSubScopesProcessor();
+      var islandVariableCreator = new VariableCreator {Name = "Initialize Results"};
+      var groupVariableCreator = new VariableCreator {Name = "Initialize Group Results"};
+
+      var layerUssp = new UniformSubScopesProcessor();
+      var layerVariableCreator = new VariableCreator();
+
+      var initLayerAnalyzerPlaceholder = new Placeholder {Name = "Layer Analyzer (Placeholder)"};
+      var initIslandAnalyzerPlaceholder = new Placeholder {Name = "Island Analyzer (Placeholder)"};
+      var initGlobalAnalyzerPlacerholder = new Placeholder {Name = "Global Analyzer (Placeholder)"};
+      var resultsCollector = new ResultsCollector();
+
+      var processIslandsUssp = new UniformSubScopesProcessor {Name = "Process Islands", Parallel = new BoolValue(true)};
+      var initIslandEvaluationsAss = new Assigner {Name = "Init Island Evaluations"};
+
+      var incrementGenerationDr = new IntCounter {Name = "Increment Generations"};
+      var incrementEvaluatedSolutionDr = new DataReducer {Name = "Increment Evaluated Solutions"};
+
+      var elderMigrator = CreateEldersEmigrator();
+      var newLayerOpener = CreateLayerOpener();
+      var reseeder = CreateReseeder();
+
+      var analyzeLayerUssp = new UniformSubScopesProcessor();
+
+      var layerAnalyzerPlaceholder = new Placeholder {Name = "Layer Analyzer (Placeholder)"};
+      var layerResultsCollector = new ResultsCollector {Name = "Collect Additional Infos"};
+      var islandAnalyzerPlaceholder = new Placeholder {Name = "Island Analyzer (Placeholder)"};
+      var islandResultsCollector = new ResultsCollector {Name = "Collect layer results into IslandResults"};
+
+      var globalAnalyzerPlacerholder = new Placeholder {Name = "Global Analyzer (Placeholder)"};
+
+      var groupingOperator = new GroupedLayerOperator {Name = "Grouped Analyzer"};
+      var groupAnalyzer = new Placeholder {Name = "Group Analyzer (Placeholder)"};
+      var groupResultsExtractor = new ResultsExtractor {Name = "Collect group results into variable"};
+      var groupResultsCollector = new ResultsCollector {Name = "Collect group results into into global results"};
+      var groupLayerNumberResultsCollector = new ResultsCollector {Name = "Add Layernumber to Results"};
+
+      var matingPoolCreator = new MatingPoolCreator();
+      var matingPoolUssp = new UniformSubScopesProcessor {Name = "Process Mating Pools"};
+      var alpsMainOperator = new AlpsGeneticAlgorithmMainOperator();
+
+      var setIslandEvaluatedSolutions = new DataReducer {Name = "Set IslandEvaluatedSolutions"};
+
+      var migrationThresholdCounter = new IntCounter {Name = "Increment Counter for Migrations"};
+      var migrationThresholdAss = new Assigner {Name = "Reset Counter for Migrations"};
+      var migrationCounter = new IntCounter {Name = "Increment  Migrations"};
+      var selectforMigrationUssp = new UniformSubScopesProcessor();
+      var emigrantSelector = new Placeholder {Name = "Emigrant Selector (Placeholder)"};
+      var migrator = new LayerMigrator();
+      var replaceforMigrationUssp = new UniformSubScopesProcessor();
+      var immigrantSelector = new Placeholder {Name = "Immigrant Replacer (Placeholder)"};
+
+      var migrateComparator = new Comparator();
+      var migrateCondBranch = new ConditionalBranch {Name = "Migrate?"};
+
+      var terminator = new TerminationOperator();
+
+      #endregion
+
+      globalVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>(GenerationsParametername, new IntValue(0)));
+      globalVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>(MigrationsParametername, new IntValue(0)));
+
+      islandVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>(OpenLayersParametername, new IntValue(1)));
+      islandVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>(IslandResultsParametername));
+
+      layerVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>(LayerParametername, new IntValue(0)));
+      layerVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>(LayerResultsParametername));
+
+      groupVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>(GroupResultsParametername));
+      initLayerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
+      initIslandAnalyzerPlaceholder.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
+      initGlobalAnalyzerPlacerholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(GenerationsParametername));
+      resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>(IslandResultsParametername, "", IslandResultsParametername));
+      resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>(GroupResultsParametername, "", GroupResultsParametername));
+      resultsCollector.CollectedValues.Add(new ValueLookupParameter<IntValue>(MigrationsParametername));
+      resultsCollector.CopyValue = new BoolValue(false);
+
+      initIslandEvaluationsAss.LeftSideParameter.ActualName = IslandEvaluatedSolutions.Name;
+      initIslandEvaluationsAss.RightSideParameter.Value = new IntValue(0);
+
+      incrementGenerationDr.ValueParameter.ActualName = GenerationsParametername;
+
+      incrementEvaluatedSolutionDr.ParameterToReduce.ActualName = IslandEvaluatedSolutions.Name;
+      incrementEvaluatedSolutionDr.TargetParameter.ActualName = EvaluatedSolutions.Name;
+      incrementEvaluatedSolutionDr.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      incrementEvaluatedSolutionDr.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+
+      setIslandEvaluatedSolutions.ParameterToReduce.ActualName = LayerEvaluatedSolutionsParameter.Name;
+      setIslandEvaluatedSolutions.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      setIslandEvaluatedSolutions.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
+      setIslandEvaluatedSolutions.TargetParameter.ActualName = IslandEvaluatedSolutions.Name;
+
+
+      migrationThresholdCounter.ValueParameter.ActualName = MigrationThresholdParametername;
+
+      migrateComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
+      migrateComparator.LeftSideParameter.ActualName = MigrationThresholdParametername;
+      migrateComparator.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
+      migrateComparator.ResultParameter.ActualName = MigrateParametername;
+
+      migrateCondBranch.ConditionParameter.ActualName = MigrateParametername;
+
+      migrationCounter.ValueParameter.ActualName = MigrationsParametername;
+      migrationThresholdAss.LeftSideParameter.ActualName = MigrationThresholdParametername;
+      migrationThresholdAss.RightSideParameter.Value = new IntValue(0);
+
+      selectforMigrationUssp.Depth = new IntValue(2);
+      emigrantSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
+
+      replaceforMigrationUssp.Depth = new IntValue(2);
+      immigrantSelector.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
+
+      groupAnalyzer.OperatorParameter.ActualName = GroupAnalyzerParameter.Name;
+      groupLayerNumberResultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("LayerNumber"));
+      groupLayerNumberResultsCollector.ResultsParameter.ActualName = GroupResultsParametername;
+
+      layerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
+      layerResultsCollector.ResultsParameter.ActualName = LayerResultsParametername;
+      layerResultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(LayerParametername));
+      islandAnalyzerPlaceholder.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
+      islandResultsCollector.ResultsParameter.ActualName = IslandResultsParametername;
+      islandResultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>(LayerResultsParametername));
+      globalAnalyzerPlacerholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+      groupResultsExtractor.SourceNameParameter.Value = new StringValue("GroupScope");
+      groupResultsExtractor.TargetNameParameter.Value = new StringValue(GroupResultsParametername);
+      groupResultsCollector.CollectedValues.Add(new LookupParameter<ItemArray<ResultCollection>>(GroupResultsParametername));
+      matingPoolCreator.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
+
+      ParemetrizeMainOperator(alpsMainOperator);
+
+      //flow
+      OperatorGraph.InitialOperator = globalVariableCreator;
+      globalVariableCreator.Successor = islandVarCreatorUssp;
+      islandVarCreatorUssp.Operator = islandVariableCreator;
+      islandVariableCreator.Successor = layerUssp;
+      layerUssp.Operator = layerVariableCreator;
+      layerVariableCreator.Successor = initLayerAnalyzerPlaceholder;
+      initLayerAnalyzerPlaceholder.Successor = null;
+      layerUssp.Successor = initIslandAnalyzerPlaceholder;
+      initLayerAnalyzerPlaceholder.Successor = null;
+      islandVarCreatorUssp.Successor = initGlobalAnalyzerPlacerholder;
+      initGlobalAnalyzerPlacerholder.Successor = resultsCollector;
+      resultsCollector.Successor = processIslandsUssp;
+      processIslandsUssp.Operator = initIslandEvaluationsAss;
+      initIslandEvaluationsAss.Successor = matingPoolCreator;
+      matingPoolCreator.Successor = matingPoolUssp;
+      matingPoolUssp.Operator = alpsMainOperator;
+      alpsMainOperator.Successor = null;
+      matingPoolUssp.Successor = elderMigrator;
+      elderMigrator.Successor = newLayerOpener;
+      newLayerOpener.Successor = reseeder;
+      reseeder.Successor = analyzeLayerUssp;
+      analyzeLayerUssp.Operator = layerAnalyzerPlaceholder;
+      layerAnalyzerPlaceholder.Successor = layerResultsCollector;
+      layerResultsCollector.Successor = null;
+
+      analyzeLayerUssp.Successor = islandAnalyzerPlaceholder;
+      islandAnalyzerPlaceholder.Successor = islandResultsCollector;
+      islandResultsCollector.Successor = setIslandEvaluatedSolutions;
+      setIslandEvaluatedSolutions.Successor = null;
+
+      processIslandsUssp.Successor = incrementGenerationDr;
+      incrementGenerationDr.Successor = incrementEvaluatedSolutionDr;
+      incrementEvaluatedSolutionDr.Successor = migrationThresholdCounter;
+
+      migrationThresholdCounter.Successor = migrateComparator;
+
+      migrateComparator.Successor = migrateCondBranch;
+      migrateCondBranch.FalseBranch = null;
+      migrateCondBranch.TrueBranch = migrationThresholdAss;
+      migrationThresholdAss.Successor = migrationCounter;
+
+      migrationCounter.Successor = selectforMigrationUssp;
+      selectforMigrationUssp.Operator = emigrantSelector;
+      emigrantSelector.Successor = null;
+      selectforMigrationUssp.Successor = migrator;
+
+      migrator.Successor = replaceforMigrationUssp;
+      replaceforMigrationUssp.Operator = immigrantSelector;
+      immigrantSelector.Successor = null;
+      replaceforMigrationUssp.Successor = null;
+
+      migrateCondBranch.Successor = globalAnalyzerPlacerholder;
+
+
+      globalAnalyzerPlacerholder.Successor = groupingOperator;
+      groupingOperator.Operator = groupAnalyzer;
+      groupAnalyzer.Successor = groupLayerNumberResultsCollector;
+      groupLayerNumberResultsCollector.Successor = null;
+      groupingOperator.Successor = groupResultsExtractor;
+      groupResultsExtractor.Successor = groupResultsCollector;
+      groupResultsCollector.Successor = terminator;
+      terminator.ContinueBranch = processIslandsUssp;
+    }
+
+    private void ParemetrizeMainOperator(AlpsGeneticAlgorithmMainOperator alpsMainOperator) {
+      alpsMainOperator.RandomParameter.ActualName = LayerRandomParameter.Name;
+      alpsMainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
+      alpsMainOperator.EvaluatedSolutionsParameter.ActualName = LayerEvaluatedSolutionsParameter.Name;
+      alpsMainOperator.QualityParameter.ActualName = QualityParameter.Name;
+      alpsMainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      alpsMainOperator.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      alpsMainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
+      alpsMainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      alpsMainOperator.MutatorParameter.ActualName = MutatorParameter.ActualName;
+      alpsMainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      alpsMainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
+      alpsMainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
+      alpsMainOperator.PlusSelectionParameter.ActualName = PlusSelectionParameter.Name;
+      alpsMainOperator.AgeParameter.ActualName = AgeParameter.Name;
+      alpsMainOperator.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
+      alpsMainOperator.AgeIncrementParameter.Value = new DoubleValue(1.0);
+    }
+
+    private void AddParameters() {
+      Parameters.Add(new ValueLookupParameter<IRandom>("GlobalRandom", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<IRandom>("IslandRandom", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<IRandom>("LayerRandom", "A pseudo random number generator."));
+
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
+
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfLayers", "The number of Layers per Island."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfIslands", "The number of islands."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MigrationInterval", "The number of generations that should pass between migration phases."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Migrator", "The migration strategy."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("EmigrantsSelector", "Selects the individuals that will be migrated."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("ImmigrationReplacer", "Replaces some of the original population with the immigrants."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("CurrentPopulationSize", "The current size of the population of solutions."));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
+      Parameters.Add(new ValueLookupParameter<ITerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop"));
+
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The age of individuals."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent."));
+      Parameters.Add(new ValueLookupParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MatingPoolRange", "The range of sub - populations used for creating a mating pool. (1 = current + previous sub-population)"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize"));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the islands."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("IslandAnalyzer", "The operator used to analyze each island."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("LayerAnalyzer", "The operator used to analyze each Layer."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("GroupAnalyzer", "The operator used to analyze each Layergroup."));
+
+      Parameters.Add(new LookupParameter<IntValue>(LayerEvaluatedSolutionsParameterName, "The number of times a solution has been evaluated."));
+      Parameters.Add(new LookupParameter<IntValue>("IslandEvaluatedSolutions", "The number of times a solution has been evaluated on one island."));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times a solution has been evaluated on one island."));
+
+      Parameters.Add(new ValueLookupParameter<BoolValue>(MigrateParametername, "Migrate the island?"));
+    }
+
+    private CombinedOperator CreateEldersEmigrator() {
+      var eldersEmigrator = new CombinedOperator {Name = "Emigrate Elders"};
+      var selectorProsessor = new UniformSubScopesProcessor();
+      var eldersSelector = new EldersSelector();
+      var shiftToRightMigrator = new UnidirectionalRingMigrator {Name = "Shift elders to next layer"};
+      var mergingProsessor = new UniformSubScopesProcessor();
+      var mergingReducer = new MergingReducer();
+      var subScopesCounter = new SubScopesCounter();
+      var reduceToPopulationSizeBranch = new ConditionalBranch {Name = "ReduceToPopulationSize?"};
+      var countCalculator = new ExpressionCalculator {Name = "CurrentPopulationSize = Min(CurrentPopulationSize, PopulationSize)"};
+      var bestSelector = new BestSelector();
+      var rightReducer = new RightReducer();
+
+      eldersEmigrator.OperatorGraph.InitialOperator = selectorProsessor;
+
+      selectorProsessor.Operator = eldersSelector;
+      selectorProsessor.Successor = shiftToRightMigrator;
+
+      eldersSelector.AgeParameter.ActualName = AgeParameter.Name;
+      eldersSelector.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
+      eldersSelector.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
+      eldersSelector.LayerParameter.ActualName = LayerParametername;
+      eldersSelector.Successor = null;
+
+      shiftToRightMigrator.ClockwiseMigrationParameter.Value = new BoolValue(true);
+      shiftToRightMigrator.Successor = mergingProsessor;
+
+      mergingProsessor.Operator = mergingReducer;
+
+      mergingReducer.Successor = subScopesCounter;
+
+      subScopesCounter.ValueParameter.ActualName = CurrentPopulationSizeParameter.Name;
+      subScopesCounter.AccumulateParameter.Value = new BoolValue(false);
+      subScopesCounter.Successor = reduceToPopulationSizeBranch;
+
+      reduceToPopulationSizeBranch.ConditionParameter.ActualName = ReduceToPopulationSizeParameter.Name;
+      reduceToPopulationSizeBranch.TrueBranch = countCalculator;
+
+      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>(PopulationSizeParameter.Name));
+      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>(CurrentPopulationSizeParameter.Name));
+      countCalculator.ExpressionParameter.Value = new StringValue("CurrentPopulationSize PopulationSize CurrentPopulationSize PopulationSize < if toint");
+      countCalculator.ExpressionResultParameter.ActualName = CurrentPopulationSizeParameter.Name;
+      countCalculator.Successor = bestSelector;
+
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = CurrentPopulationSizeParameter.Name;
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.Successor = rightReducer;
+
+      return eldersEmigrator;
+    }
+
+    private CombinedOperator CreateLayerOpener() {
+      var layerOpener = new CombinedOperator {Name = "Open new Layer if needed"};
+      var maxLayerReached = new Comparator {Name = "MaxLayersReached = OpenLayers >= NumberOfLayers"};
+      var maxLayerReachedBranch = new ConditionalBranch {Name = "MaxLayersReached?"};
+      var openNewLayerCalculator = new ExpressionCalculator {Name = "OpenNewLayer = Generations >= AgeLimits[OpenLayers - 1]"};
+      var openNewLayerBranch = new ConditionalBranch {Name = "OpenNewLayer?"};
+      var layerCreator = new LastLayerCloner {Name = "Create Layer"};
+      var updateLayerNumber = new Assigner {Name = "Layer = OpenLayers"};
+      var historyWiper = new ResultsHistoryWiper {Name = "Clear History in Results"};
+      var createChildrenViaCrossover = new AlpsGeneticAlgorithmMainOperator();
+      var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter {Name = "Update EvaluatedSolutions"};
+      var incrOpenLayers = new IntCounter {Name = "Incr. OpenLayers"};
+
+      layerOpener.OperatorGraph.InitialOperator = maxLayerReached;
+
+      maxLayerReached.LeftSideParameter.ActualName = OpenLayersParametername;
+      maxLayerReached.RightSideParameter.ActualName = NumberOfLayersParameter.Name;
+      maxLayerReached.ResultParameter.ActualName = "MaxLayerReached";
+      maxLayerReached.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      maxLayerReached.Successor = maxLayerReachedBranch;
+
+      maxLayerReachedBranch.ConditionParameter.ActualName = "MaxLayerReached";
+      maxLayerReachedBranch.FalseBranch = openNewLayerCalculator;
+
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntArray>(AgeLimitsParameter.Name));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>(GenerationsParametername));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>(NumberOfLayersParameter.Name));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>(OpenLayersParametername));
+      openNewLayerCalculator.ExpressionResultParameter.ActualName = "OpenNewLayer";
+      openNewLayerCalculator.ExpressionParameter.Value = new StringValue("Generations 1 + AgeLimits OpenLayers 1 - [] >");
+      openNewLayerCalculator.Successor = openNewLayerBranch;
+
+      openNewLayerBranch.ConditionParameter.ActualName = "OpenNewLayer";
+      openNewLayerBranch.TrueBranch = layerCreator;
+
+      layerCreator.NewLayerOperator = updateLayerNumber;
+      layerCreator.Successor = incrOpenLayers;
+
+      updateLayerNumber.LeftSideParameter.ActualName = LayerParametername;
+      updateLayerNumber.RightSideParameter.ActualName = OpenLayersParametername;
+      updateLayerNumber.Successor = historyWiper;
+
+      historyWiper.ResultsParameter.ActualName = LayerResultsParametername;
+      historyWiper.Successor = createChildrenViaCrossover;
+
+      // Maybe use only crossover and no elitism instead of "default operator"
+      createChildrenViaCrossover.RandomParameter.ActualName = LayerRandomParameter.Name;
+      createChildrenViaCrossover.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
+      createChildrenViaCrossover.EvaluatedSolutionsParameter.ActualName = LayerEvaluatedSolutionsParameterName;
+      createChildrenViaCrossover.QualityParameter.ActualName = QualityParameter.Name;
+      createChildrenViaCrossover.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      createChildrenViaCrossover.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      createChildrenViaCrossover.SelectorParameter.ActualName = SelectorParameter.Name;
+      createChildrenViaCrossover.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      createChildrenViaCrossover.MutatorParameter.ActualName = MutatorParameter.Name;
+      createChildrenViaCrossover.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      createChildrenViaCrossover.ElitesParameter.ActualName = ElitesParameter.Name;
+      createChildrenViaCrossover.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
+      createChildrenViaCrossover.PlusSelectionParameter.ActualName = PlusSelectionParameter.Name;
+      createChildrenViaCrossover.AgeParameter.ActualName = AgeParameter.Name;
+      createChildrenViaCrossover.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
+      createChildrenViaCrossover.AgeIncrementParameter.Value = new DoubleValue(0.0);
+      createChildrenViaCrossover.Successor = incrEvaluatedSolutionsForNewLayer;
+
+      incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = LayerEvaluatedSolutionsParameter.Name;
+      incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
+
+      incrOpenLayers.ValueParameter.ActualName = OpenLayersParametername;
+      incrOpenLayers.Increment = new IntValue(1);
+
+      return layerOpener;
+    }
+
+    private CombinedOperator CreateReseeder() {
+      var reseeder = new CombinedOperator {Name = "Reseed Layer Zero if needed"};
+      var reseedingController = new ReseedingController {Name = "Reseeding needed (Generation % AgeGap == 0)?"};
+      var removeIndividuals = new SubScopesRemover();
+      var createIndividuals = new SolutionsCreator();
+      var initializeAgeProsessor = new UniformSubScopesProcessor();
+      var initializeAge = new VariableCreator {Name = "Initialize Age"};
+      var incrEvaluatedSolutionsAfterReseeding = new SubScopesCounter {Name = "Update EvaluatedSolutions"};
+
+      reseeder.OperatorGraph.InitialOperator = reseedingController;
+
+      reseedingController.GenerationsParameter.ActualName = GenerationsParametername;
+      reseedingController.AgeGapParameter.ActualName = AgeGapParameter.Name;
+      reseedingController.FirstLayerOperator = removeIndividuals;
+      reseedingController.Successor = null;
+
+      removeIndividuals.Successor = createIndividuals;
+
+      createIndividuals.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
+      createIndividuals.Successor = initializeAgeProsessor;
+
+      initializeAgeProsessor.Operator = initializeAge;
+      initializeAgeProsessor.Successor = incrEvaluatedSolutionsAfterReseeding;
+
+      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>(AgeParameter.Name, new DoubleValue(0)));
+
+      incrEvaluatedSolutionsAfterReseeding.ValueParameter.ActualName = LayerEvaluatedSolutionsParameter.Name;
+      incrEvaluatedSolutionsAfterReseeding.AccumulateParameter.Value = new BoolValue(true);
+
+      return reseeder;
+    }
+  }
+}
Index: /branches/IslandALPS/IslandALPS/3.3/Offspring Selection/IslandAlpsOffspringSelectionAlgorithm.cs
===================================================================
--- /branches/IslandALPS/IslandALPS/3.3/Offspring Selection/IslandAlpsOffspringSelectionAlgorithm.cs	(revision 13686)
+++ /branches/IslandALPS/IslandALPS/3.3/Offspring Selection/IslandAlpsOffspringSelectionAlgorithm.cs	(revision 13686)
@@ -0,0 +1,886 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Algorithms.ALPS;
+using HeuristicLab.Analysis;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Random;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.IslandALPS {
+  [Item("IslandAlpsOffspringSelectionAlgorithm", "An island version of ALPS with offspring selection")]
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 100)]
+  public class IslandAlpsOffspringSelectionAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+    public string Filename { get; set; }
+
+    #region Problem Properties
+
+    public override Type ProblemType {
+      get { return typeof (ISingleObjectiveHeuristicOptimizationProblem); }
+    }
+
+    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
+      get { return (ISingleObjectiveHeuristicOptimizationProblem) base.Problem; }
+      set { base.Problem = value; }
+    }
+
+    #endregion
+
+    #region Parameter Properties
+
+    #region ALPSParameter
+
+    public IValueParameter<IntValue> AgeGapParameter { get { return (IValueParameter<IntValue>) Parameters["AgeGap"]; } }
+
+    public IValueParameter<EnumValue<AgingScheme>> AgingSchemeParameter { get { return (IValueParameter<EnumValue<AgingScheme>>) Parameters["AgingScheme"]; } } 
+    public IValueParameter<DoubleValue> AgeInheritanceParameter {   get { return (IValueParameter<DoubleValue>) Parameters["AgeInheritance"]; } } 
+    public IValueParameter<IntArray> AgeLimitsParameter {   get { return (IValueParameter<IntArray>) Parameters["AgeLimits"]; }   } 
+    public IValueParameter<BoolValue> ReduceToPopulationSizeParameter {   get { return (IValueParameter<BoolValue>) Parameters["ReduceToPopulationSize"]; }   } 
+    public IValueParameter<IntValue> NumberOfLayersParameter {   get { return (IValueParameter<IntValue>) Parameters["NumberOfLayers"]; } } 
+    public IValueParameter<MultiAnalyzer> LayerAnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["LayerAnalyzer"]; } } 
+    public IValueParameter<MultiAnalyzer> GroupAnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["GroupAnalyzer"]; } } 
+    #endregion
+    #region OSParameter
+
+    public IFixedValueParameter<DoubleValue> SuccessRatioParameter { get { return (IFixedValueParameter<DoubleValue>) Parameters["SuccessRatio"]; } }
+    public IFixedValueParameter<DoubleValue> ComparisonFactorParameter { get { return (IFixedValueParameter<DoubleValue>) Parameters["ComparisonFactor"]; } }
+    public IFixedValueParameter<DoubleValue> MaximumSelectionPressureParameter { get { return (IFixedValueParameter<DoubleValue>) Parameters["MaximumSelectionPressure"]; } }
+    public IFixedValueParameter<BoolValue> OffspringSelectionBeforeMutationParameter { get { return (IFixedValueParameter<BoolValue>) Parameters["OffspringSelectionBeforeMutation"]; } }
+    public IFixedValueParameter<IntValue> SelectedParentsParameter { get { return (IFixedValueParameter<IntValue>) Parameters["SelectedParents"]; } }
+    public IFixedValueParameter<BoolValue> FillPopulationWithParentsParameter { get { return (IFixedValueParameter<BoolValue>) Parameters["FillPopulationWithParents"]; } }
+    #endregion
+
+    #region IslandParameter
+
+    public IValueParameter<MultiAnalyzer> IslandAnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["IslandAnalyzer"]; } } 
+    public IValueParameter<IntValue> NumberOfIslandsParameter {   get { return (IValueParameter<IntValue>) Parameters["NumberOfIslands"]; } } 
+    public IValueParameter<PercentValue> MigrationRateParameter {   get { return (IValueParameter<PercentValue>) Parameters["MigrationRate"]; } } 
+    public IValueParameter<IntValue> MigrationIntervalParameter {   get { return (IValueParameter<IntValue>) Parameters["MigrationInterval"]; } } 
+    public IConstrainedValueParameter<IMigrator> MigratorParameter {   get { return (IConstrainedValueParameter<IMigrator>) Parameters["Migrator"]; } } 
+    public IConstrainedValueParameter<ISelector> EmigrantsSelectorParameter {   get { return (IConstrainedValueParameter<ISelector>) Parameters["EmigrantsSelector"]; } } 
+    public IConstrainedValueParameter<IReplacer> ImmigrationReplacerParameter {   get { return (IConstrainedValueParameter<IReplacer>) Parameters["ImmigrationReplacer"]; } } 
+    #endregion
+
+    #region GeneralParameter
+
+    public IValueParameter<IntValue> SeedParameter {   get { return (IValueParameter<IntValue>) Parameters["Seed"]; } } 
+    public IValueParameter<BoolValue> SetSeedRandomlyParameter {   get { return (IValueParameter<BoolValue>) Parameters["SetSeedRandomly"]; } } 
+    public IValueParameter<IntValue> PopulationSizeParameter {   get { return (IValueParameter<IntValue>) Parameters["PopulationSize"]; } } 
+    public IValueParameter<MultiAnalyzer> AnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["Analyzer"]; } } 
+    public IConstrainedValueParameter<ISelector> SelectorParameter {   get { return (IConstrainedValueParameter<ISelector>) Parameters["Selector"]; } } 
+    public IConstrainedValueParameter<ICrossover> CrossoverParameter {   get { return (IConstrainedValueParameter<ICrossover>) Parameters["Crossover"]; } }
+    public IValueParameter<PercentValue> MutationProbabilityParameter {   get { return (IValueParameter<PercentValue>) Parameters["MutationProbability"]; } } 
+    public IConstrainedValueParameter<IManipulator> MutatorParameter {   get { return (IConstrainedValueParameter<IManipulator>) Parameters["Mutator"]; } }
+    public IValueParameter<IntValue> ElitesParameter {   get { return (IValueParameter<IntValue>) Parameters["Elites"]; } }
+    public IFixedValueParameter<BoolValue> ReevaluateElitesParameter {   get { return (IFixedValueParameter<BoolValue>) Parameters["ReevaluateElites"]; } }
+    public IValueParameter<MultiTerminator> TerminatorParameter {   get { return (IValueParameter<MultiTerminator>) Parameters["Terminator"]; } } 
+    #endregion
+
+    #endregion
+
+    #region Properties
+
+    public IntValue Seed {
+      get { return SeedParameter.Value; }
+      set { SeedParameter.Value = value; }
+    }
+
+    public BoolValue SetSeedRandomly {
+      get { return SetSeedRandomlyParameter.Value; }
+      set { SetSeedRandomlyParameter.Value = value; }
+    }
+
+    public IntValue PopulationSize {
+      get { return PopulationSizeParameter.Value; }
+      set { PopulationSizeParameter.Value = value; }
+    }
+
+    public IntValue NumberOfIslands {
+      get { return NumberOfIslandsParameter.Value; }
+      set { NumberOfIslandsParameter.Value = value; }
+    }
+
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+      set { AnalyzerParameter.Value = value; }
+    }
+
+    public MultiAnalyzer IslandAnalyzer {
+      get { return IslandAnalyzerParameter.Value; }
+      set { IslandAnalyzerParameter.Value = value; }
+    }
+
+    public MultiAnalyzer LayerAnalyzer {
+      get { return LayerAnalyzerParameter.Value; }
+      set { LayerAnalyzerParameter.Value = value; }
+    }
+
+    public MultiAnalyzer GroupAnalyzer {
+      get { return GroupAnalyzerParameter.Value; }
+      set { GroupAnalyzerParameter.Value = value; }
+    }
+
+    public ISelector Selector {
+      get { return SelectorParameter.Value; }
+      set { SelectorParameter.Value = value; }
+    }
+
+    public ICrossover Crossover {
+      get { return CrossoverParameter.Value; }
+      set { CrossoverParameter.Value = value; }
+    }
+
+    public PercentValue MutationProbability {
+      get { return MutationProbabilityParameter.Value; }
+      set { MutationProbabilityParameter.Value = value; }
+    }
+
+    public IManipulator Mutator {
+      get { return MutatorParameter.Value; }
+      set { MutatorParameter.Value = value; }
+    }
+
+    public IntValue Elites {
+      get { return ElitesParameter.Value; }
+      set { ElitesParameter.Value = value; }
+    }
+
+    public bool ReevaluteElites {
+      get { return ReevaluateElitesParameter.Value.Value; }
+      set { ReevaluateElitesParameter.Value.Value = value; }
+    }
+
+    public MultiTerminator Terminators {
+      get { return TerminatorParameter.Value; }
+    }
+
+    public EnumValue<AgingScheme> AgingScheme {
+      get { return AgingSchemeParameter.Value; }
+      set { AgingSchemeParameter.Value = value; }
+    }
+
+    public IntValue AgeGap {
+      get { return AgeGapParameter.Value; }
+      set { AgeGapParameter.Value = value; }
+    }
+
+    public DoubleValue AgeInheritance {
+      get { return AgeInheritanceParameter.Value; }
+      set { AgeInheritanceParameter.Value = value; }
+    }
+
+    public IntArray AgeLimits {
+      get { return AgeLimitsParameter.Value; }
+      set { AgeLimitsParameter.Value = value; }
+    }
+
+    public IntValue NumberOfLayers {
+      get { return NumberOfLayersParameter.Value; }
+      set { NumberOfLayersParameter.Value = value; }
+    }
+
+    #endregion
+
+    #region Helper Properties
+
+    private IslandAlpsOffspringSelectionAlgorithmMainLoop MainLoop {
+      get { return OperatorGraph.Iterate().OfType<IslandAlpsOffspringSelectionAlgorithmMainLoop>().First(); }
+    }
+
+    private SolutionsCreator SolutionsCreator {
+      get { return OperatorGraph.Iterate().OfType<SolutionsCreator>().First(); }
+    }
+
+    #endregion
+
+    #region Preconfigured Terminators
+
+    [Storable] private readonly ComparisonTerminator<IntValue> generationsTerminator;
+    [Storable] private readonly ComparisonTerminator<IntValue> evaluationsTerminator;
+    [Storable] private readonly SingleObjectiveQualityTerminator qualityTerminator;
+    [Storable] private readonly ExecutionTimeTerminator executionTimeTerminator;
+
+    #endregion
+
+    #region Preconfigured Analyzers
+
+    [Storable] private readonly BestAverageWorstQualityAnalyzer qualityAnalyzer;
+    [Storable] private readonly BestAverageWorstQualityAnalyzer islandQualityAnalyzer;
+    [Storable] private readonly BestAverageWorstQualityAnalyzer layerQualityAnalyzer;
+    [Storable] private readonly BestAverageWorstQualityAnalyzer groupQualityAnalyzer;
+
+    #endregion
+
+    #region Constructors
+
+    [StorableConstructor]
+    private IslandAlpsOffspringSelectionAlgorithm(bool deserializing) : base(deserializing) {}
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      InitializeEventHandler();
+    }
+
+    private IslandAlpsOffspringSelectionAlgorithm(IslandAlpsOffspringSelectionAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+      //clone Properties
+
+      //analyzer
+      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      islandQualityAnalyzer = cloner.Clone(original.islandQualityAnalyzer);
+      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
+      groupQualityAnalyzer = cloner.Clone(original.groupQualityAnalyzer);
+      //terminator
+      generationsTerminator = cloner.Clone(original.generationsTerminator);
+      evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
+      qualityTerminator = cloner.Clone(original.qualityTerminator);
+      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
+
+      InitializeEventHandler();
+    }
+
+    public IslandAlpsOffspringSelectionAlgorithm() {
+    
+      AddParameters();
+
+      #region create Operators
+
+      var globalRandomCreator = new RandomCreator();
+      var islandLayerCreator = new SubScopesCreator {Name = "Create Islands"};
+      var islandUssp = new UniformSubScopesProcessor();
+      var islandRandomCreator = new LocalRandomCreator();
+      var layerZeroCreator = new SubScopesCreator {Name = "Create Layer 0"};
+      var layerZeroUssp = new UniformSubScopesProcessor();
+      var layerRandomCreator = new LocalRandomCreator();
+      var islandSolutionsCounter = new DataReducer {Name = "Count IslandSolutions"};
+      var layerSolutionCreator = new SolutionsCreator();
+      var ageInitializerUssp = new UniformSubScopesProcessor();
+      var ageInitializerVc = new VariableCreator {Name = "Initialize Age"};
+      var evaluatedSolutionsVc = new VariableCreator {Name = "Create LayerEvaluatedSolutions"};
+      var evaluatedSolutionsCounter = new SubScopesCounter {Name = "Count LayerEvaluatedSolutions"};
+      var globalEvaluatedSolutionsCounter = new DataReducer {Name = "Count GlobalSolutions"};
+      var resultsCollector = new ResultsCollector();
+      var mainLoop = new IslandAlpsOffspringSelectionAlgorithmMainLoop();
+
+      #endregion
+
+      #region Set selectors
+
+      var selectors = ApplicationManager.Manager.GetInstances<ISelector>()
+                                        .Where(s => !(s is IMultiObjectiveSelector))
+                                        .OrderBy(s => Name);
+      foreach (var selector in selectors)
+        SelectorParameter.ValidValues.Add(selector);
+
+      var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
+      if (defaultSelector != null) {
+        defaultSelector.PressureParameter.Value = new DoubleValue(4.0);
+        SelectorParameter.Value = defaultSelector;
+      }
+
+      #endregion
+
+      #region Create Analyzers
+      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      islandQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      groupQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      #endregion
+
+      #region Create terminators
+
+      generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
+      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) {Name = "Evaluations"};
+      qualityTerminator = new SingleObjectiveQualityTerminator {Name = "Quality"};
+      executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
+
+      #endregion
+
+      #region Operator Graph
+
+      globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
+      globalRandomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
+      globalRandomCreator.SetSeedRandomlyParameter.Value = null;
+      globalRandomCreator.SeedParameter.ActualName = SeedParameter.Name;
+      globalRandomCreator.SeedParameter.Value = null;
+
+      //create islands
+      islandLayerCreator.NumberOfSubScopesParameter.ActualName = NumberOfIslandsParameter.Name;
+
+      islandRandomCreator.GlobalRandomParameter.ActualName = globalRandomCreator.RandomParameter.ActualName;
+      islandRandomCreator.LocalRandomParameter.ActualName = "IslandRandom";
+
+      layerZeroCreator.NumberOfSubScopesParameter.Value = new IntValue(1);
+
+      islandSolutionsCounter.ParameterToReduce.Depth = 1;
+      islandSolutionsCounter.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
+      islandSolutionsCounter.TargetParameter.ActualName = "IslandEvaluatedSolutions";
+      islandSolutionsCounter.ReductionOperation.Value.Value = ReductionOperations.Sum;
+      islandSolutionsCounter.TargetOperation.Value.Value = ReductionOperations.Assign;
+
+      layerRandomCreator.GlobalRandomParameter.ActualName = globalRandomCreator.RandomParameter.ActualName;
+      layerRandomCreator.LocalRandomParameter.ActualName = "LayerRandom";
+
+      layerSolutionCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
+      layerSolutionCreator.ParallelParameter.Value = new BoolValue(true);
+
+      ageInitializerVc.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
+
+      evaluatedSolutionsVc.CollectedValues.Add(new ValueParameter<IntValue>("LayerEvaluatedSolutions", new IntValue(0)));
+
+      evaluatedSolutionsCounter.ValueParameter.ActualName = "LayerEvaluatedSolutions";
+
+      globalEvaluatedSolutionsCounter.ParameterToReduce.Depth = 1;
+      globalEvaluatedSolutionsCounter.ParameterToReduce.ActualName = "IslandEvaluatedSolutions";
+      globalEvaluatedSolutionsCounter.TargetParameter.ActualName = "EvaluatedSolutions";
+      globalEvaluatedSolutionsCounter.ReductionOperation.Value.Value = ReductionOperations.Sum;
+      globalEvaluatedSolutionsCounter.TargetOperation.Value.Value = ReductionOperations.Assign;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedSolutions"));
+
+      //flow
+      OperatorGraph.InitialOperator = globalRandomCreator;
+      globalRandomCreator.Successor = islandLayerCreator;
+      islandLayerCreator.Successor = islandUssp;
+      islandUssp.Operator = islandRandomCreator;
+      islandRandomCreator.Successor = layerZeroCreator;
+      layerZeroCreator.Successor = layerZeroUssp;
+      layerZeroUssp.Operator = layerRandomCreator;
+      layerRandomCreator.Successor = layerSolutionCreator;
+      layerSolutionCreator.Successor = ageInitializerUssp;
+      ageInitializerUssp.Operator = ageInitializerVc;
+      ageInitializerVc.Successor = null;
+      ageInitializerUssp.Successor = evaluatedSolutionsVc;
+      evaluatedSolutionsVc.Successor = evaluatedSolutionsCounter;
+      evaluatedSolutionsCounter.Successor = null;
+      layerZeroUssp.Successor = islandSolutionsCounter;
+      islandSolutionsCounter.Successor = null;
+      islandUssp.Successor = globalEvaluatedSolutionsCounter;
+      globalEvaluatedSolutionsCounter.Successor = resultsCollector;
+      resultsCollector.Successor = mainLoop;
+
+      #endregion
+
+      #region parametrize
+
+      ParameterizeAnalyzers();
+      UpdateAnalyzers();
+      ParameterizeSelectors();
+      UpdateTerminators();
+      ParameterizeAgeLimits();
+      ParametrizeMigration();
+
+      #endregion
+
+      InitializeEventHandler();
+    }
+
+    private void AddParameters() {
+      #region ALPSParameter
+
+      Parameters.Add(new ValueParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers.", new IntValue(5)));
+      Parameters.Add(new ValueParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent.", new DoubleValue(1)));
+      Parameters.Add(new ValueParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer.", new IntArray(new int[0])) {Hidden = true});
+      Parameters.Add(new ValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
+      Parameters.Add(new ValueParameter<BoolValue>("ReduceToPopulationSize", ".", new BoolValue(true)));
+
+      Parameters.Add(new ValueParameter<IntValue>("NumberOfLayers", "", new IntValue(100000)));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("GroupAnalyzer", "The operator used to analyze each layergroup.", new MultiAnalyzer()));
+
+      #endregion
+      #region OS
+
+      Parameters.Add(new FixedValueParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1].", new DoubleValue(1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
+      Parameters.Add(new FixedValueParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<IntValue>("SelectedParents", "How much parents should be selected each time the offspring selection step is performed until the population is filled. This parameter should be about the same or twice the size of PopulationSize for smaller problems, and less for large problems.", new IntValue(200)));
+      Parameters.Add(new FixedValueParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded.", new BoolValue(false)) { Hidden = true });
+
+      #endregion
+
+      #region IslandParameter
+
+      Parameters.Add(new ValueParameter<IntValue>("NumberOfIslands", "The number of islands.", new IntValue(5)));
+      Parameters.Add(new ValueParameter<PercentValue>("MigrationRate", "How many individuals should migrate.", new PercentValue(0.15)));
+      Parameters.Add(new ValueParameter<IntValue>("MigrationInterval", "The number Generations before a migration occurs.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer()));
+      Parameters.Add(new ConstrainedValueParameter<IMigrator>("Migrator", "The migration strategy."));
+      Parameters.Add(new ConstrainedValueParameter<ISelector>("EmigrantsSelector", "Selects the individuals that will be migrated."));
+      Parameters.Add(new ConstrainedValueParameter<IReplacer>("ImmigrationReplacer", "Selects the population from the unification of the original population and the immigrants."));
+
+      #endregion
+
+      #region GeneralParameter   
+
+      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
+      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
+      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
+      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) {Hidden = true});
+      Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
+
+      #endregion
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IslandAlpsOffspringSelectionAlgorithm(this, cloner);
+    }
+
+    #endregion
+
+    #region events
+
+    protected override void OnProblemChanged() {
+      base.OnProblemChanged();
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
+      foreach (var op in Problem.Operators.OfType<IOperator>()) {
+        ParameterizeStochasticOperator(op);
+      }
+
+      ParameterizeSolutionsCreator();
+      ParameterizeMainLoop();
+      ParameterizeSelectors();
+      ParameterizeAnalyzers();
+      ParameterizeIterationBasedOperators();
+
+      UpdateAnalyzers();
+      UpdateCrossovers();
+      UpdateMutators();
+      UpdateTerminators();
+    }
+
+    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
+      base.Problem_SolutionCreatorChanged(sender, e);
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeSolutionsCreator();
+    }
+
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      base.Problem_EvaluatorChanged(sender, e);
+
+      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
+      ParameterizeSolutionsCreator();
+      ParameterizeMainLoop();
+      ParameterizeSelectors();
+      ParameterizeAnalyzers();
+      ParameterizeTerminators();
+
+      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+
+      UpdateAnalyzers();
+      UpdateCrossovers();
+      UpdateMutators();
+      UpdateTerminators();
+    }
+
+    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
+      base.Problem_OperatorsChanged(sender, e);
+      UpdateAnalyzers();
+      UpdateTerminators();
+    }
+
+    #endregion
+
+    #region Update Functions
+
+    private void UpdateCrossovers() {
+      var oldCrossover = CrossoverParameter.Value;
+      var defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
+      CrossoverParameter.ValidValues.Clear();
+      foreach (var crossover in Problem.Operators.OfType<ICrossover>().OrderBy(x => x.Name)) {
+        ParameterizeStochasticOperatorForLayer(crossover);
+        CrossoverParameter.ValidValues.Add(crossover);
+      }
+      if (oldCrossover != null) {
+        var crossover = CrossoverParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldCrossover.GetType());
+        if (crossover != null) CrossoverParameter.Value = crossover;
+        else oldCrossover = null;
+      }
+      if (oldCrossover == null && defaultCrossover != null)
+        CrossoverParameter.Value = defaultCrossover;
+    }
+
+    private void UpdateMutators() {
+      var oldMutator = MutatorParameter.Value;
+      MutatorParameter.ValidValues.Clear();
+      foreach (var mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name)) {
+        ParameterizeStochasticOperatorForLayer(mutator);
+        MutatorParameter.ValidValues.Add(mutator);
+      }
+      if (oldMutator != null) {
+        var mutator = MutatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMutator.GetType());
+        if (mutator != null) MutatorParameter.Value = mutator;
+      }
+    }
+
+    private void UpdateAnalyzers() {
+      LayerAnalyzer.Operators.Clear();
+      IslandAnalyzer.Operators.Clear();
+      GroupAnalyzer.Operators.Clear();
+      Analyzer.Operators.Clear();
+
+      //add analyzer
+      GroupAnalyzer.Operators.Add(groupQualityAnalyzer, false);
+      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, false);
+      IslandAnalyzer.Operators.Add(islandQualityAnalyzer, false);
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      //depth for each analyzer gets set when added
+      if (Problem != null) {
+        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+          IslandAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
+          LayerAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
+          GroupAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
+        }
+      }
+    }
+
+    private void UpdateTerminators() {
+      var newTerminators = new Dictionary<ITerminator, bool> {
+        {
+          generationsTerminator,
+          !Terminators.Operators.Contains(generationsTerminator) ||
+          Terminators.Operators.ItemChecked(generationsTerminator)
+        }, {
+          evaluationsTerminator,
+          Terminators.Operators.Contains(evaluationsTerminator) &&
+          Terminators.Operators.ItemChecked(evaluationsTerminator)
+        }, {
+          qualityTerminator,
+          Terminators.Operators.Contains(qualityTerminator) && Terminators.Operators.ItemChecked(qualityTerminator)
+        }, {
+          executionTimeTerminator,
+          Terminators.Operators.Contains(executionTimeTerminator) &&
+          Terminators.Operators.ItemChecked(executionTimeTerminator)
+        }
+      };
+      if (Problem != null) {
+        foreach (var terminator in Problem.Operators.OfType<ITerminator>())
+          newTerminators.Add(terminator,
+                             !Terminators.Operators.Contains(terminator) || Terminators.Operators.ItemChecked(terminator));
+      }
+
+      Terminators.Operators.Clear();
+
+      foreach (var newTerminator in newTerminators)
+        Terminators.Operators.Add(newTerminator.Key, newTerminator.Value);
+    }
+
+    private void InitializeEventHandler() {
+      PopulationSizeParameter.ValueChanged += PopulationSizeParameter_ValueChanged;
+      PopulationSize.ValueChanged += PopulationSize_ValueChanged;
+      ElitesParameter.ValueChanged += ElitesParameter_ValueChanged;
+      Elites.ValueChanged += Elites_ValueChanged;
+      MigrationRateParameter.Value.ValueChanged += MigrationRate_ValueChanged;
+      MigrationRateParameter.ValueChanged += MigrationRate_ValueChanged;
+
+      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded;
+      IslandAnalyzer.Operators.ItemsAdded += IslandAnalyzerOperators_ItemsAdded;
+      LayerAnalyzer.Operators.ItemsAdded += LayerAnalyzerOperators_ItemsAdded;
+      GroupAnalyzer.Operators.ItemsAdded += GroupAnalyzerOperators_ItemsAdded;
+
+      if (Problem != null) {
+        Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      }
+
+      AgeGapParameter.ValueChanged += AgeGapParameter_ValueChanged;
+      AgeGap.ValueChanged += AgeGap_ValueChanged;
+      AgingSchemeParameter.ValueChanged += AgingSchemeParameter_ValueChanged;
+      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
+
+      NumberOfLayersParameter.ValueChanged += NumberOfLayersParameter_ValueChanged;
+      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
+    }
+
+    private void MigrationRate_ValueChanged(object sender, EventArgs e) {
+      var migrationSize = (int) Math.Ceiling(MigrationRateParameter.Value.Value*PopulationSize.Value);
+      foreach (var selector in EmigrantsSelectorParameter.ValidValues) {
+        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(migrationSize);
+      }
+    }
+
+    private void GroupAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
+      foreach (var analyzer in e.Items) {
+        IParameter resultParameter;
+        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
+          var lookupParameter = resultParameter as ILookupParameter;
+          if (lookupParameter != null)
+            lookupParameter.ActualName = "GroupResults";
+        }
+        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
+          parameter.Depth = 1;
+        }
+      }
+    }
+
+    private void IslandAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
+      foreach (var analyzer in e.Items) {
+        IParameter resultParameter;
+        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
+          var lookupParameter = resultParameter as ILookupParameter;
+          if (lookupParameter != null)
+            lookupParameter.ActualName = "IslandResults";
+        }
+        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
+          parameter.Depth = 2;
+        }
+      }
+    }
+
+    private void LayerAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
+      foreach (var analyzer in e.Items) {
+        IParameter resultParameter;
+        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
+          var lookupParameter = resultParameter as ILookupParameter;
+          if (lookupParameter != null)
+            lookupParameter.ActualName = "LayerResults";
+        }
+        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
+          parameter.Depth = 1;
+        }
+      }
+    }
+
+    private void AnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
+      foreach (var analyzer in e.Items) {
+        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
+          parameter.Depth = 3;
+        }
+      }
+    }
+
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeMainLoop();
+      ParameterizeSelectors();
+      ParameterizeAnalyzers();
+    }
+
+    private void ElitesParameter_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSelectors();
+    }
+
+    private void Elites_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSelectors();
+    }
+
+    private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSelectors();
+    }
+
+    private void PopulationSize_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSelectors();
+    }
+
+    private void NumberOfLayersParameter_ValueChanged(object sender, EventArgs e) {
+      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
+      ParameterizeAgeLimits();
+    }
+
+    private void NumberOfLayers_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+
+    private void AgeGapParameter_ValueChanged(object sender, EventArgs e) {
+      AgeGap.ValueChanged += AgeGap_ValueChanged;
+      ParameterizeAgeLimits();
+    }
+
+    private void AgeGap_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+
+    private void AgingSchemeParameter_ValueChanged(object sender, EventArgs e) {
+      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
+      ParameterizeAgeLimits();
+    }
+
+    private void AgingScheme_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+
+    private void ParameterizeAgeLimits() {
+      var scheme = AgingScheme.Value;
+      var ageGap = AgeGap.Value;
+      var numberOfLayers = NumberOfLayers.Value;
+      AgeLimits = scheme.CalculateAgeLimits(ageGap, numberOfLayers);
+    }
+
+    private void ParameterizeMainLoop() {
+      MainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
+      MainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
+      MainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
+      MainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
+      MainLoop.AgeParameter.ActualName = "Age";
+      MainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
+      MainLoop.IslandRandomParameter.ActualName = "IslandRandom";
+      MainLoop.LayerRandomParameter.ActualName = "LayerRandom";
+
+      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      MainLoop.LayerEvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
+
+      MainLoop.NumberOfIslandsParameter.ActualName = NumberOfIslandsParameter.Name;
+      MainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
+      MainLoop.MigrationIntervalParameter.ActualName = MigrationIntervalParameter.Name;
+      MainLoop.MigratorParameter.ActualName = MigratorParameter.Name;
+      MainLoop.EmigrantsSelectorParameter.ActualName = EmigrantsSelectorParameter.Name;
+      MainLoop.ImmigrationReplacerParameter.ActualName = ImmigrationReplacerParameter.Name;
+
+      MainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      MainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
+      MainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
+      MainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
+      MainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      MainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      MainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
+      MainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
+
+      MainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
+      MainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
+      MainLoop.IslandAnalyzerParameter.ActualName = IslandAnalyzerParameter.Name;
+      MainLoop.GroupAnalyzerParameter.ActualName = GroupAnalyzerParameter.Name;
+
+      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+
+      MainLoop.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      MainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+      MainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      MainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
+      MainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
+    }
+
+    private void ParametrizeMigration() {
+      var migrationSize = (int) Math.Ceiling(MigrationRateParameter.Value.Value*PopulationSize.Value);
+      foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name)) {
+        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(migrationSize);
+        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
+
+        ParameterizeStochasticOperatorForLayer(selector);
+
+        EmigrantsSelectorParameter.ValidValues.Add(selector);
+      }
+
+      foreach (var replacer in ApplicationManager.Manager.GetInstances<IReplacer>().OrderBy(x => x.Name)) {
+        ParameterizeStochasticOperatorForLayer(replacer);
+        ImmigrationReplacerParameter.ValidValues.Add(replacer);
+      }
+
+      MigratorParameter.ValidValues.Add(new LayerMigrator());
+    }
+
+    private void ParameterizeSolutionsCreator() {
+      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+    }
+
+    private void ParameterizeSelectors() {
+      foreach (var selector in SelectorParameter.ValidValues) {
+        selector.CopySelected = new BoolValue(true);
+        selector.NumberOfSelectedSubScopesParameter.ActualName = SelectedParentsParameter.Name;
+        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
+        ParameterizeStochasticOperatorForLayer(selector);
+      }
+
+      if (Problem != null) {
+        foreach (var selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
+          ParametrizeSingleObjectiveSelector(selector);
+        }
+        foreach (var replacer in EmigrantsSelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
+          ParametrizeSingleObjectiveSelector(replacer);
+        }
+        foreach (var selector in ImmigrationReplacerParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
+          ParametrizeSingleObjectiveSelector(selector);
+        }
+      }
+    }
+
+    private void ParametrizeSingleObjectiveSelector(ISingleObjectiveSelector selector) {
+      selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+      selector.MaximizationParameter.Hidden = true;
+      selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+      selector.QualityParameter.Hidden = true;
+    }
+
+    private void ParameterizeAnalyzers() {
+      layerQualityAnalyzer.ResultsParameter.ActualName = "LayerResults";
+      layerQualityAnalyzer.ResultsParameter.Hidden = true;
+
+      islandQualityAnalyzer.ResultsParameter.ActualName = "IslandResults";
+      islandQualityAnalyzer.ResultsParameter.Hidden = true;
+
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      qualityAnalyzer.ResultsParameter.Hidden = true;
+
+      groupQualityAnalyzer.ResultsParameter.ActualName = "GroupResults";
+      groupQualityAnalyzer.ResultsParameter.Hidden = true;
+
+      if (Problem != null) {
+        SetAnalyzerParameter(layerQualityAnalyzer);
+        SetAnalyzerParameter(islandQualityAnalyzer);
+        SetAnalyzerParameter(qualityAnalyzer);
+        SetAnalyzerParameter(groupQualityAnalyzer);
+      }
+    }
+
+    private void SetAnalyzerParameter(BestAverageWorstQualityAnalyzer analyzer) {
+      analyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+      analyzer.MaximizationParameter.Hidden = true;
+      analyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+      analyzer.QualityParameter.Hidden = true;
+      analyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+      analyzer.BestKnownQualityParameter.Hidden = true;
+    }
+
+    private void ParameterizeTerminators() {
+      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
+    }
+
+    private void ParameterizeIterationBasedOperators() {
+      if (Problem != null) {
+        foreach (var op in Problem.Operators.OfType<IIterationBasedOperator>()) {
+          op.IterationsParameter.ActualName = "Generations";
+          op.IterationsParameter.Hidden = true;
+          op.MaximumIterationsParameter.ActualName = generationsTerminator.ThresholdParameter.Name;
+          op.MaximumIterationsParameter.Hidden = true;
+        }
+      }
+    }
+
+    private void ParameterizeStochasticOperator(IOperator op) {
+      var stochasticOp = op as IStochasticOperator;
+      if (stochasticOp != null) {
+        stochasticOp.RandomParameter.ActualName = "GlobalRandom";
+        stochasticOp.RandomParameter.Hidden = true;
+      }
+    }
+
+    private void ParameterizeStochasticOperatorForLayer(IOperator op) {
+      var stochasticOp = op as IStochasticOperator;
+      if (stochasticOp != null) {
+        stochasticOp.RandomParameter.ActualName = "LayerRandom";
+        stochasticOp.RandomParameter.Hidden = true;
+      }
+    }
+
+    #endregion
+  }
+}
Index: /branches/IslandALPS/IslandALPS/3.3/Offspring Selection/IslandAlpsOffspringSelectionAlgorithmMainLoop.cs
===================================================================
--- /branches/IslandALPS/IslandALPS/3.3/Offspring Selection/IslandAlpsOffspringSelectionAlgorithmMainLoop.cs	(revision 13686)
+++ /branches/IslandALPS/IslandALPS/3.3/Offspring Selection/IslandAlpsOffspringSelectionAlgorithmMainLoop.cs	(revision 13686)
@@ -0,0 +1,689 @@
+﻿using HeuristicLab.Algorithms.ALPS;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.IslandALPS {
+  [Item("IslandAlpsOffspringSelectionAlgorithmMainLoop", "An island ALPS offspring selection main loop operator.")]
+  [StorableClass]
+  public class IslandAlpsOffspringSelectionAlgorithmMainLoop : AlgorithmOperator {
+    private const string LayerResultsParametername = "LayerResults";
+    private const string GenerationsParametername = "Generations";
+    private const string IslandResultsParametername = "IslandResults";
+    private const string LayerParametername = "Layer";
+    private const string MigrationsParametername = "Migrations";
+    private const string OpenLayersParametername = "OpenLayers";
+    private const string GroupResultsParametername = "GroupResults";
+    private const string MigrationThresholdParametername = "MigrationThreshold";
+    private const string MigrateParametername = "Migrate";
+    private const string LayerEvaluatedSolutionsParameterName = "LayerEvaluatedSolutions";
+
+    [StorableConstructor]
+    private IslandAlpsOffspringSelectionAlgorithmMainLoop(bool deserializing) : base(deserializing) {}
+
+    #region Parameter Properties
+
+    public ValueLookupParameter<IRandom> GlobalRandomParameter {
+      get { return (ValueLookupParameter<IRandom>) Parameters["GlobalRandom"]; }
+    }
+
+    public ValueLookupParameter<IRandom> IslandRandomParameter {
+      get { return (ValueLookupParameter<IRandom>) Parameters["IslandRandom"]; }
+    }
+
+    public ValueLookupParameter<IRandom> LayerRandomParameter {
+      get { return (ValueLookupParameter<IRandom>) Parameters["LayerRandom"]; }
+    }
+
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>) Parameters["Maximization"]; }
+    }
+
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>) Parameters["Quality"]; }
+    }
+
+    public ValueLookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ValueLookupParameter<DoubleValue>) Parameters["BestKnownQuality"]; }
+    }
+
+    public ValueLookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ValueLookupParameter<IntValue>) Parameters["PopulationSize"]; }
+    }
+
+    public ValueLookupParameter<IOperator> SelectorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Selector"]; }
+    }
+
+    public ValueLookupParameter<IOperator> CrossoverParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Crossover"]; }
+    }
+
+    public ValueLookupParameter<PercentValue> MutationProbabilityParameter {
+      get { return (ValueLookupParameter<PercentValue>) Parameters["MutationProbability"]; }
+    }
+
+    public ValueLookupParameter<IOperator> MutatorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Mutator"]; }
+    }
+
+    public ValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Evaluator"]; }
+    }
+
+    public ValueLookupParameter<IntValue> ElitesParameter {
+      get { return (ValueLookupParameter<IntValue>) Parameters["Elites"]; }
+    }
+
+    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
+      get { return (IValueLookupParameter<BoolValue>) Parameters["ReevaluateElites"]; }
+    }
+
+    public ValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (ValueLookupParameter<ResultCollection>) Parameters["Results"]; }
+    }
+
+    public ILookupParameter<ITerminator> TerminatorParameter {
+      get { return (ILookupParameter<ITerminator>) Parameters["Terminator"]; }
+    }
+
+    public ValueLookupParameter<IOperator> AnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Analyzer"]; }
+    }
+
+    public ValueLookupParameter<IOperator> IslandAnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["IslandAnalyzer"]; }
+    }
+
+    public ValueLookupParameter<IOperator> LayerAnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["LayerAnalyzer"]; }
+    }
+
+    public ValueLookupParameter<IOperator> GroupAnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["GroupAnalyzer"]; }
+    }
+
+    public LookupParameter<IntValue> LayerEvaluatedSolutionsParameter {
+      get { return (LookupParameter<IntValue>) Parameters[LayerEvaluatedSolutionsParameterName]; }
+    }
+
+    public LookupParameter<IntValue> EvaluatedSolutions {
+      get { return (LookupParameter<IntValue>) Parameters["EvaluatedSolutions"]; }
+    }
+
+    #region island
+
+    public ValueLookupParameter<IntValue> NumberOfIslandsParameter {
+      get { return (ValueLookupParameter<IntValue>) Parameters["NumberOfIslands"]; }
+    }
+
+    public ValueLookupParameter<IntValue> MigrationIntervalParameter {
+      get { return (ValueLookupParameter<IntValue>) Parameters["MigrationInterval"]; }
+    }
+
+    public ValueLookupParameter<PercentValue> MigrationRateParameter {
+      get { return (ValueLookupParameter<PercentValue>) Parameters["MigrationRate"]; }
+    }
+
+    public ValueLookupParameter<IOperator> MigratorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["Migrator"]; }
+    }
+
+    public ValueLookupParameter<IOperator> EmigrantsSelectorParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["EmigrantsSelector"]; }
+    }
+
+    public ValueLookupParameter<IOperator> ImmigrationReplacerParameter {
+      get { return (ValueLookupParameter<IOperator>) Parameters["ImmigrationReplacer"]; }
+    }
+
+    public ValueLookupParameter<BoolValue> Migrate {
+      get { return (ValueLookupParameter<BoolValue>) Parameters[MigrateParametername]; }
+    }
+
+    public LookupParameter<IntValue> IslandEvaluatedSolutions {
+      get { return (LookupParameter<IntValue>) Parameters["IslandEvaluatedSolutions"]; }
+    }
+
+    #endregion
+
+    #region alps
+
+    public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>) Parameters["CurrentPopulationSize"]; }
+    }
+
+    public IValueLookupParameter<IntValue> NumberOfLayersParameter {
+      get { return (IValueLookupParameter<IntValue>) Parameters["NumberOfLayers"]; }
+    }
+
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>) Parameters["Age"]; }
+    }
+
+    public IValueLookupParameter<IntValue> AgeGapParameter {
+      get { return (IValueLookupParameter<IntValue>) Parameters["AgeGap"]; }
+    }
+
+    public IValueLookupParameter<DoubleValue> AgeInheritanceParameter {
+      get { return (IValueLookupParameter<DoubleValue>) Parameters["AgeInheritance"]; }
+    }
+
+    public IValueLookupParameter<IntArray> AgeLimitsParameter {
+      get { return (IValueLookupParameter<IntArray>) Parameters["AgeLimits"]; }
+    }
+
+    public IValueLookupParameter<IntValue> MatingPoolRangeParameter {
+      get { return (IValueLookupParameter<IntValue>) Parameters["MatingPoolRange"]; }
+    }
+
+    public IValueLookupParameter<BoolValue> ReduceToPopulationSizeParameter {
+      get { return (IValueLookupParameter<BoolValue>) Parameters["ReduceToPopulationSize"]; }
+    }
+
+    #endregion
+
+    #region OS
+    public ILookupParameter<DoubleValue> ComparisonFactorParameter {
+      get { return (ILookupParameter<DoubleValue>) Parameters["ComparisonFactor"]; }
+    }
+
+    public IValueLookupParameter<DoubleValue> SuccessRatioParameter {
+      get { return (IValueLookupParameter<DoubleValue>) Parameters["SuccessRatio"]; }
+    }
+
+    public IValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
+      get { return (IValueLookupParameter<DoubleValue>) Parameters["MaximumSelectionPressure"]; }
+    }
+
+    public IValueLookupParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
+      get { return (IValueLookupParameter<BoolValue>) Parameters["OffspringSelectionBeforeMutation"]; }
+    }
+
+    public IValueLookupParameter<BoolValue> FillPopulationWithParentsParameter {
+      get { return (IValueLookupParameter<BoolValue>) Parameters["FillPopulationWithParents"]; }
+    }
+
+    public ILookupParameter<DoubleValue> CurrentSuccessRatioParameter {
+      get { return (ILookupParameter<DoubleValue>) Parameters["CurrentSuccessRatio"]; }
+    }
+
+    public ILookupParameter<DoubleValue> SelectionPressureParameter {
+      get { return (ILookupParameter<DoubleValue>) Parameters["SelectionPressure"]; }
+    }
+    #endregion
+
+    #endregion
+
+    private IslandAlpsOffspringSelectionAlgorithmMainLoop(IslandAlpsOffspringSelectionAlgorithmMainLoop original, Cloner cloner) :
+      base(original, cloner) {}
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IslandAlpsOffspringSelectionAlgorithmMainLoop(this, cloner);
+    }
+
+    public IslandAlpsOffspringSelectionAlgorithmMainLoop() {
+      AddParameters();
+
+      #region create Operators
+
+      var globalVariableCreator = new VariableCreator {Name = "Create global values"};
+      var islandVarCreatorUssp = new UniformSubScopesProcessor();
+      var islandVariableCreator = new VariableCreator {Name = "Initialize Results"};
+      var groupVariableCreator = new VariableCreator {Name = "Initialize Group Results"};
+
+      var layerUssp = new UniformSubScopesProcessor();
+      var layerVariableCreator = new VariableCreator();
+
+      var initLayerAnalyzerPlaceholder = new Placeholder {Name = "Layer Analyzer (Placeholder)"};
+      var initIslandAnalyzerPlaceholder = new Placeholder {Name = "Island Analyzer (Placeholder)"};
+      var initGlobalAnalyzerPlacerholder = new Placeholder {Name = "Global Analyzer (Placeholder)"};
+      var resultsCollector = new ResultsCollector();
+
+      var processIslandsUssp = new UniformSubScopesProcessor {Name = "Process Islands", Parallel = new BoolValue(true)};
+      var initIslandEvaluationsAss = new Assigner {Name = "Init Island Evaluations"};
+
+      var incrementGenerationDr = new IntCounter {Name = "Increment Generations"};
+      var incrementEvaluatedSolutionDr = new DataReducer {Name = "Increment Evaluated Solutions"};
+
+      var elderMigrator = CreateEldersEmigrator();
+      var newLayerOpener = CreateLayerOpener();
+      var reseeder = CreateReseeder();
+
+      var analyzeLayerUssp = new UniformSubScopesProcessor();
+
+      var layerAnalyzerPlaceholder = new Placeholder {Name = "Layer Analyzer (Placeholder)"};
+      var layerResultsCollector = new ResultsCollector {Name = "Collect Additional Infos"};
+      var islandAnalyzerPlaceholder = new Placeholder {Name = "Island Analyzer (Placeholder)"};
+      var islandResultsCollector = new ResultsCollector {Name = "Collect layer results into IslandResults"};
+
+      var globalAnalyzerPlacerholder = new Placeholder {Name = "Global Analyzer (Placeholder)"};
+
+      var groupingOperator = new GroupedLayerOperator {Name = "Grouped Analyzer"};
+      var groupAnalyzer = new Placeholder {Name = "Group Analyzer (Placeholder)"};
+      var groupResultsExtractor = new ResultsExtractor {Name = "Collect group results into variable"};
+      var groupResultsCollector = new ResultsCollector {Name = "Collect group results into into global results"};
+      var groupLayerNumberResultsCollector = new ResultsCollector {Name = "Add Layernumber to Results"};
+
+      var matingPoolCreator = new MatingPoolCreator();
+      var matingPoolUssp = new UniformSubScopesProcessor {Name = "Process Mating Pools"};
+      var alpsMainOperator = new AlpsOffspringSelectionGeneticAlgorithmMainOperator();
+
+      var setIslandEvaluatedSolutions = new DataReducer {Name = "Set IslandEvaluatedSolutions"};
+
+      var migrationThresholdCounter = new IntCounter {Name = "Increment Counter for Migrations"};
+      var migrationThresholdAss = new Assigner {Name = "Reset Counter for Migrations"};
+      var migrationCounter = new IntCounter {Name = "Increment  Migrations"};
+      var selectforMigrationUssp = new UniformSubScopesProcessor();
+      var emigrantSelector = new Placeholder {Name = "Emigrant Selector (Placeholder)"};
+      var migrator = new LayerMigrator();
+      var replaceforMigrationUssp = new UniformSubScopesProcessor();
+      var immigrantSelector = new Placeholder {Name = "Immigrant Replacer (Placeholder)"};
+
+      var migrateComparator = new Comparator();
+      var migrateCondBranch = new ConditionalBranch {Name = "Migrate?"};
+
+      var terminator = new TerminationOperator();
+
+      #endregion
+
+      globalVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>(GenerationsParametername, new IntValue(0)));
+      globalVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>(MigrationsParametername, new IntValue(0)));
+
+      islandVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>(OpenLayersParametername, new IntValue(1)));
+      islandVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>(IslandResultsParametername));
+
+      layerVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>(LayerParametername, new IntValue(0)));
+      layerVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>(LayerResultsParametername));
+
+      groupVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>(GroupResultsParametername));
+      initLayerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
+      initIslandAnalyzerPlaceholder.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
+      initGlobalAnalyzerPlacerholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(GenerationsParametername));
+      resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>(IslandResultsParametername, "", IslandResultsParametername));
+      resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>(GroupResultsParametername, "", GroupResultsParametername));
+      resultsCollector.CollectedValues.Add(new ValueLookupParameter<IntValue>(MigrationsParametername));
+      resultsCollector.CopyValue = new BoolValue(false);
+
+      initIslandEvaluationsAss.LeftSideParameter.ActualName = IslandEvaluatedSolutions.Name;
+      initIslandEvaluationsAss.RightSideParameter.Value = new IntValue(0);
+
+      incrementGenerationDr.ValueParameter.ActualName = GenerationsParametername;
+
+      incrementEvaluatedSolutionDr.ParameterToReduce.ActualName = IslandEvaluatedSolutions.Name;
+      incrementEvaluatedSolutionDr.TargetParameter.ActualName = EvaluatedSolutions.Name;
+      incrementEvaluatedSolutionDr.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      incrementEvaluatedSolutionDr.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+
+      setIslandEvaluatedSolutions.ParameterToReduce.ActualName = LayerEvaluatedSolutionsParameter.Name;
+      setIslandEvaluatedSolutions.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      setIslandEvaluatedSolutions.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
+      setIslandEvaluatedSolutions.TargetParameter.ActualName = IslandEvaluatedSolutions.Name;
+
+
+      migrationThresholdCounter.ValueParameter.ActualName = MigrationThresholdParametername;
+
+      migrateComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
+      migrateComparator.LeftSideParameter.ActualName = MigrationThresholdParametername;
+      migrateComparator.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
+      migrateComparator.ResultParameter.ActualName = MigrateParametername;
+
+      migrateCondBranch.ConditionParameter.ActualName = MigrateParametername;
+
+      migrationCounter.ValueParameter.ActualName = MigrationsParametername;
+      migrationThresholdAss.LeftSideParameter.ActualName = MigrationThresholdParametername;
+      migrationThresholdAss.RightSideParameter.Value = new IntValue(0);
+
+      selectforMigrationUssp.Depth = new IntValue(2);
+      emigrantSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
+
+      replaceforMigrationUssp.Depth = new IntValue(2);
+      immigrantSelector.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
+
+      groupAnalyzer.OperatorParameter.ActualName = GroupAnalyzerParameter.Name;
+      groupLayerNumberResultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("LayerNumber"));
+      groupLayerNumberResultsCollector.ResultsParameter.ActualName = GroupResultsParametername;
+
+      layerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
+      layerResultsCollector.ResultsParameter.ActualName = LayerResultsParametername;
+      layerResultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(LayerParametername));
+      islandAnalyzerPlaceholder.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
+      islandResultsCollector.ResultsParameter.ActualName = IslandResultsParametername;
+      islandResultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>(LayerResultsParametername));
+      globalAnalyzerPlacerholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+      groupResultsExtractor.SourceNameParameter.Value = new StringValue("GroupScope");
+      groupResultsExtractor.TargetNameParameter.Value = new StringValue(GroupResultsParametername);
+      groupResultsCollector.CollectedValues.Add(new LookupParameter<ItemArray<ResultCollection>>(GroupResultsParametername));
+      matingPoolCreator.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
+
+      ParemetrizeMainOperator(alpsMainOperator);
+
+      //flow
+      OperatorGraph.InitialOperator = globalVariableCreator;
+      globalVariableCreator.Successor = islandVarCreatorUssp;
+      islandVarCreatorUssp.Operator = islandVariableCreator;
+      islandVariableCreator.Successor = layerUssp;
+      layerUssp.Operator = layerVariableCreator;
+      layerVariableCreator.Successor = initLayerAnalyzerPlaceholder;
+      initLayerAnalyzerPlaceholder.Successor = null;
+      layerUssp.Successor = initIslandAnalyzerPlaceholder;
+      initLayerAnalyzerPlaceholder.Successor = null;
+      islandVarCreatorUssp.Successor = initGlobalAnalyzerPlacerholder;
+      initGlobalAnalyzerPlacerholder.Successor = resultsCollector;
+      resultsCollector.Successor = processIslandsUssp;
+      processIslandsUssp.Operator = initIslandEvaluationsAss;
+      initIslandEvaluationsAss.Successor = matingPoolCreator;
+      matingPoolCreator.Successor = matingPoolUssp;
+      matingPoolUssp.Operator = alpsMainOperator;
+      alpsMainOperator.Successor = null;
+      matingPoolUssp.Successor = elderMigrator;
+      elderMigrator.Successor = newLayerOpener;
+      newLayerOpener.Successor = reseeder;
+      reseeder.Successor = analyzeLayerUssp;
+      analyzeLayerUssp.Operator = layerAnalyzerPlaceholder;
+      layerAnalyzerPlaceholder.Successor = layerResultsCollector;
+      layerResultsCollector.Successor = null;
+
+      analyzeLayerUssp.Successor = islandAnalyzerPlaceholder;
+      islandAnalyzerPlaceholder.Successor = islandResultsCollector;
+      islandResultsCollector.Successor = setIslandEvaluatedSolutions;
+      setIslandEvaluatedSolutions.Successor = null;
+
+      processIslandsUssp.Successor = incrementGenerationDr;
+      incrementGenerationDr.Successor = incrementEvaluatedSolutionDr;
+      incrementEvaluatedSolutionDr.Successor = migrationThresholdCounter;
+
+      migrationThresholdCounter.Successor = migrateComparator;
+
+      migrateComparator.Successor = migrateCondBranch;
+      migrateCondBranch.FalseBranch = null;
+      migrateCondBranch.TrueBranch = migrationThresholdAss;
+      migrationThresholdAss.Successor = migrationCounter;
+
+      migrationCounter.Successor = selectforMigrationUssp;
+      selectforMigrationUssp.Operator = emigrantSelector;
+      emigrantSelector.Successor = null;
+      selectforMigrationUssp.Successor = migrator;
+
+      migrator.Successor = replaceforMigrationUssp;
+      replaceforMigrationUssp.Operator = immigrantSelector;
+      immigrantSelector.Successor = null;
+      replaceforMigrationUssp.Successor = null;
+
+      migrateCondBranch.Successor = globalAnalyzerPlacerholder;
+
+
+      globalAnalyzerPlacerholder.Successor = groupingOperator;
+      groupingOperator.Operator = groupAnalyzer;
+      groupAnalyzer.Successor = groupLayerNumberResultsCollector;
+      groupLayerNumberResultsCollector.Successor = null;
+      groupingOperator.Successor = groupResultsExtractor;
+      groupResultsExtractor.Successor = groupResultsCollector;
+      groupResultsCollector.Successor = terminator;
+      terminator.ContinueBranch = processIslandsUssp;
+    }
+
+    private void ParemetrizeMainOperator(AlpsOffspringSelectionGeneticAlgorithmMainOperator alpsMainOperator) {
+      alpsMainOperator.RandomParameter.ActualName = LayerRandomParameter.Name;
+      alpsMainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
+      alpsMainOperator.EvaluatedSolutionsParameter.ActualName = LayerEvaluatedSolutionsParameter.Name;
+      alpsMainOperator.QualityParameter.ActualName = QualityParameter.Name;
+      alpsMainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      alpsMainOperator.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      alpsMainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
+      alpsMainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      alpsMainOperator.MutatorParameter.ActualName = MutatorParameter.ActualName;
+      alpsMainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      alpsMainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
+      alpsMainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
+      alpsMainOperator.AgeParameter.ActualName = AgeParameter.Name;
+      alpsMainOperator.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
+      alpsMainOperator.AgeIncrementParameter.Value = new DoubleValue(1.0);
+
+      alpsMainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      alpsMainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+      alpsMainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      alpsMainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
+      alpsMainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
+      alpsMainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
+      alpsMainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";              
+    }
+
+    private void AddParameters() {
+      Parameters.Add(new ValueLookupParameter<IRandom>("GlobalRandom", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<IRandom>("IslandRandom", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<IRandom>("LayerRandom", "A pseudo random number generator."));
+
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
+
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfLayers", "The number of Layers per Island."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfIslands", "The number of islands."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MigrationInterval", "The number of generations that should pass between migration phases."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Migrator", "The migration strategy."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("EmigrantsSelector", "Selects the individuals that will be migrated."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("ImmigrationReplacer", "Replaces some of the original population with the immigrants."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("CurrentPopulationSize", "The current size of the population of solutions."));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
+      Parameters.Add(new ValueLookupParameter<ITerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop"));
+
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The age of individuals."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent."));
+      Parameters.Add(new ValueLookupParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MatingPoolRange", "The range of sub - populations used for creating a mating pool. (1 = current + previous sub-population)"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize"));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the islands."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("IslandAnalyzer", "The operator used to analyze each island."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("LayerAnalyzer", "The operator used to analyze each Layer."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("GroupAnalyzer", "The operator used to analyze each Layergroup."));
+
+      Parameters.Add(new LookupParameter<IntValue>(LayerEvaluatedSolutionsParameterName, "The number of times a solution has been evaluated."));
+      Parameters.Add(new LookupParameter<IntValue>("IslandEvaluatedSolutions", "The number of times a solution has been evaluated on one island."));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times a solution has been evaluated on one island."));
+
+      Parameters.Add(new ValueLookupParameter<BoolValue>(MigrateParametername, "Migrate the island?"));
+
+      Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
+
+      Parameters.Add(new LookupParameter<DoubleValue>("CurrentSuccessRatio", "The current success ratio."));
+      Parameters.Add(new LookupParameter<DoubleValue>("SelectionPressure", "The actual selection pressure."));
+    }
+
+    private CombinedOperator CreateEldersEmigrator() {
+      var eldersEmigrator = new CombinedOperator {Name = "Emigrate Elders"};
+      var selectorProsessor = new UniformSubScopesProcessor();
+      var eldersSelector = new EldersSelector();
+      var shiftToRightMigrator = new UnidirectionalRingMigrator {Name = "Shift elders to next layer"};
+      var mergingProsessor = new UniformSubScopesProcessor();
+      var mergingReducer = new MergingReducer();
+      var subScopesCounter = new SubScopesCounter();
+      var reduceToPopulationSizeBranch = new ConditionalBranch {Name = "ReduceToPopulationSize?"};
+      var countCalculator = new ExpressionCalculator {Name = "CurrentPopulationSize = Min(CurrentPopulationSize, PopulationSize)"};
+      var bestSelector = new BestSelector();
+      var rightReducer = new RightReducer();
+
+      eldersEmigrator.OperatorGraph.InitialOperator = selectorProsessor;
+
+      selectorProsessor.Operator = eldersSelector;
+      selectorProsessor.Successor = shiftToRightMigrator;
+
+      eldersSelector.AgeParameter.ActualName = AgeParameter.Name;
+      eldersSelector.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
+      eldersSelector.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
+      eldersSelector.LayerParameter.ActualName = "Layer";
+      eldersSelector.Successor = null;
+
+      shiftToRightMigrator.ClockwiseMigrationParameter.Value = new BoolValue(true);
+      shiftToRightMigrator.Successor = mergingProsessor;
+
+      mergingProsessor.Operator = mergingReducer;
+
+      mergingReducer.Successor = subScopesCounter;
+
+      subScopesCounter.ValueParameter.ActualName = CurrentPopulationSizeParameter.Name;
+      subScopesCounter.AccumulateParameter.Value = new BoolValue(false);
+      subScopesCounter.Successor = reduceToPopulationSizeBranch;
+
+      reduceToPopulationSizeBranch.ConditionParameter.ActualName = ReduceToPopulationSizeParameter.Name;
+      reduceToPopulationSizeBranch.TrueBranch = countCalculator;
+
+      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>(PopulationSizeParameter.Name));
+      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>(CurrentPopulationSizeParameter.Name));
+      countCalculator.ExpressionParameter.Value = new StringValue("CurrentPopulationSize PopulationSize CurrentPopulationSize PopulationSize < if toint");
+      countCalculator.ExpressionResultParameter.ActualName = CurrentPopulationSizeParameter.Name;
+      countCalculator.Successor = bestSelector;
+
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = CurrentPopulationSizeParameter.Name;
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.Successor = rightReducer;
+
+      return eldersEmigrator;
+    }
+
+
+    private CombinedOperator CreateLayerOpener() {
+      var layerOpener = new CombinedOperator {Name = "Open new Layer if needed"};
+      var maxLayerReached = new Comparator {Name = "MaxLayersReached = OpenLayers >= NumberOfLayers"};
+      var maxLayerReachedBranch = new ConditionalBranch {Name = "MaxLayersReached?"};
+      var openNewLayerCalculator = new ExpressionCalculator {Name = "OpenNewLayer = Generations >= AgeLimits[OpenLayers - 1]"};
+      var openNewLayerBranch = new ConditionalBranch {Name = "OpenNewLayer?"};
+      var layerCreator = new LastLayerCloner {Name = "Create Layer"};
+      var updateLayerNumber = new Assigner {Name = "Layer = OpenLayers"};
+      var historyWiper = new ResultsHistoryWiper {Name = "Clear History in Results"};
+      var createChildrenViaCrossover = new AlpsOffspringSelectionGeneticAlgorithmMainOperator();
+      var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter {Name = "Update EvaluatedSolutions"};
+      var incrOpenLayers = new IntCounter {Name = "Incr. OpenLayers"};
+      var newLayerResultsCollector = new ResultsCollector {Name = "Collect new Layer Results"};
+
+      layerOpener.OperatorGraph.InitialOperator = maxLayerReached;
+
+      maxLayerReached.LeftSideParameter.ActualName = "OpenLayers";
+      maxLayerReached.RightSideParameter.ActualName = NumberOfLayersParameter.Name;
+      maxLayerReached.ResultParameter.ActualName = "MaxLayerReached";
+      maxLayerReached.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      maxLayerReached.Successor = maxLayerReachedBranch;
+
+      maxLayerReachedBranch.ConditionParameter.ActualName = "MaxLayerReached";
+      maxLayerReachedBranch.FalseBranch = openNewLayerCalculator;
+
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntArray>(AgeLimitsParameter.Name));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>(NumberOfLayersParameter.Name));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("OpenLayers"));
+      openNewLayerCalculator.ExpressionResultParameter.ActualName = "OpenNewLayer";
+      openNewLayerCalculator.ExpressionParameter.Value = new StringValue("Generations 1 + AgeLimits OpenLayers 1 - [] >");
+      openNewLayerCalculator.Successor = openNewLayerBranch;
+
+      openNewLayerBranch.ConditionParameter.ActualName = "OpenNewLayer";
+      openNewLayerBranch.TrueBranch = layerCreator;
+
+      layerCreator.NewLayerOperator = updateLayerNumber;
+      layerCreator.Successor = incrOpenLayers;
+
+      updateLayerNumber.LeftSideParameter.ActualName = "Layer";
+      updateLayerNumber.RightSideParameter.ActualName = "OpenLayers";
+      updateLayerNumber.Successor = historyWiper;
+
+      historyWiper.ResultsParameter.ActualName = "LayerResults";
+      historyWiper.Successor = createChildrenViaCrossover;
+
+      // Maybe use only crossover and no elitism instead of "default operator"
+      createChildrenViaCrossover.RandomParameter.ActualName = LayerRandomParameter.Name;
+      createChildrenViaCrossover.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
+      createChildrenViaCrossover.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
+      createChildrenViaCrossover.QualityParameter.ActualName = QualityParameter.Name;
+      createChildrenViaCrossover.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      createChildrenViaCrossover.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      createChildrenViaCrossover.SelectorParameter.ActualName = SelectorParameter.Name;
+      createChildrenViaCrossover.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      createChildrenViaCrossover.MutatorParameter.ActualName = MutatorParameter.ActualName;
+      createChildrenViaCrossover.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      createChildrenViaCrossover.ElitesParameter.ActualName = ElitesParameter.Name;
+      createChildrenViaCrossover.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
+      createChildrenViaCrossover.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      createChildrenViaCrossover.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+      createChildrenViaCrossover.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
+      createChildrenViaCrossover.SelectionPressureParameter.ActualName = "SelectionPressure";
+      createChildrenViaCrossover.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      createChildrenViaCrossover.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
+      createChildrenViaCrossover.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
+      createChildrenViaCrossover.AgeParameter.ActualName = AgeParameter.Name;
+      createChildrenViaCrossover.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
+      createChildrenViaCrossover.AgeIncrementParameter.Value = new DoubleValue(0.0);
+      createChildrenViaCrossover.Successor = incrEvaluatedSolutionsForNewLayer;
+
+      incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = LayerEvaluatedSolutionsParameter.Name;
+      incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
+
+      incrOpenLayers.ValueParameter.ActualName = "OpenLayers";
+      incrOpenLayers.Increment = new IntValue(1);
+      incrOpenLayers.Successor = newLayerResultsCollector;
+
+      newLayerResultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("LayerResults", "Result set for each layer", "LayerResults"));
+      newLayerResultsCollector.CopyValue = new BoolValue(false);
+      newLayerResultsCollector.Successor = null;
+
+      return layerOpener;
+    }
+
+    private CombinedOperator CreateReseeder() {
+      var reseeder = new CombinedOperator {Name = "Reseed Layer Zero if needed"};
+      var reseedingController = new ReseedingController {Name = "Reseeding needed (Generation % AgeGap == 0)?"};
+      var removeIndividuals = new SubScopesRemover();
+      var createIndividuals = new SolutionsCreator();
+      var initializeAgeProsessor = new UniformSubScopesProcessor();
+      var initializeAge = new VariableCreator {Name = "Initialize Age"};
+      var incrEvaluatedSolutionsAfterReseeding = new SubScopesCounter {Name = "Update EvaluatedSolutions"};
+
+      reseeder.OperatorGraph.InitialOperator = reseedingController;
+
+      reseedingController.GenerationsParameter.ActualName = "Generations";
+      reseedingController.AgeGapParameter.ActualName = AgeGapParameter.Name;
+      reseedingController.FirstLayerOperator = removeIndividuals;
+      reseedingController.Successor = null;
+
+      removeIndividuals.Successor = createIndividuals;
+
+      createIndividuals.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
+      createIndividuals.Successor = initializeAgeProsessor;
+
+      initializeAgeProsessor.Operator = initializeAge;
+      initializeAgeProsessor.Successor = incrEvaluatedSolutionsAfterReseeding;
+
+      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>(AgeParameter.Name, new DoubleValue(0)));
+
+      incrEvaluatedSolutionsAfterReseeding.ValueParameter.ActualName = LayerEvaluatedSolutionsParameter.Name;
+      incrEvaluatedSolutionsAfterReseeding.AccumulateParameter.Value = new BoolValue(true);
+
+      return reseeder;
+    }
+
+
+  }
+}
