Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs	(revision 13092)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs	(revision 13095)
@@ -114,4 +114,7 @@
       get { return (IValueParameter<IntValue>)Parameters["MatingPoolRange"]; }
     }
+    private IValueParameter<BoolValue> ContinuousReseedingParameter {
+      get { return (IValueParameter<BoolValue>)Parameters["ContinuousReseeding"]; }
+    }
 
     private IValueParameter<MultiTerminator> TerminatorParameter {
@@ -195,4 +198,8 @@
       get { return MatingPoolRangeParameter.Value; }
       set { MatingPoolRangeParameter.Value = value; }
+    }
+    public BoolValue ContinuousReseeding {
+      get { return ContinuousReseedingParameter.Value; }
+      set { ContinuousReseedingParameter.Value = value; }
     }
 
@@ -296,4 +303,5 @@
 
       Parameters.Add(new ValueParameter<IntValue>("MatingPoolRange", "The range of layers used for creating a mating pool. (1 = current + previous layer)", new IntValue(1)) { Hidden = true });
+      Parameters.Add(new ValueParameter<BoolValue>("ContinuousReseeding", "Instead of replacing the lowest layer every AgeGap generations replace 1/AgeGap individuals every generation", new BoolValue(false)) { Hidden = true });
 
       Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria which sould be checked.", new MultiTerminator()));
@@ -546,6 +554,4 @@
       SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
       SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
-      MainLoop.LayerUpdator.SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
-      MainLoop.LayerUpdator.SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
     }
     private void ParameterizeMainLoop() {
@@ -555,5 +561,4 @@
       MainLoop.MainOperator.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
       MainLoop.MainOperator.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
-      MainLoop.LayerUpdator.SolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
     }
     private void ParameterizeAnalyzers() {
@@ -614,4 +619,5 @@
       int numberOfLayers = NumberOfLayers.Value;
       AgeLimits = scheme.CalculateAgeLimits(ageGap, numberOfLayers);
+      AgeLimits[AgeLimits.Length - 1] = int.MaxValue; // last layer infinite age limit
     }
 
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs	(revision 13092)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs	(revision 13095)
@@ -30,5 +30,4 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Selection;
 
 namespace HeuristicLab.Algorithms.ALPS {
@@ -61,7 +60,4 @@
       get { return OperatorGraph.Iterate().OfType<EldersEmigrator>().First(); }
     }
-    public LayerUpdator LayerUpdator {
-      get { return OperatorGraph.Iterate().OfType<LayerUpdator>().First(); }
-    }
 
     [StorableConstructor]
@@ -90,9 +86,10 @@
       var matingPoolProcessor = new UniformSubScopesProcessor();
       var initializeLayer = new Assigner() { Name = "Reset LayerEvaluatedSolutions" };
-      var mainOperator = CreatePreparedGeneticAlgorithmMainLoop();
+      var mainOperator = AlpsGeneticAlgorithmMainOperator.Create();
       var generationsIcrementor = new IntCounter() { Name = "Increment Generations" };
       var evaluatedSolutionsReducer = new DataReducer() { Name = "Increment EvaluatedSolutions" };
       var eldersEmigrator = new EldersEmigrator() { Name = "Emigrate Elders" };
-      var layerUpdator = new LayerUpdator(mainOperator) { Name = "Update Layers" };
+      var layerOpener = new LayerOpener() { Name = "Open new Layer" };
+      var layerReseeder = new LayerReseeder() { Name = "Reseed Layer Zero" };
       var layerAnalyzerProcessor = new UniformSubScopesProcessor();
       var layerAnalyzerPlaceholder = new Placeholder() { Name = "LayerAnalyzer (Placeholder)" };
@@ -146,7 +143,9 @@
       evaluatedSolutionsReducer.Successor = eldersEmigrator;
 
-      eldersEmigrator.Successor = layerUpdator;
+      eldersEmigrator.Successor = layerOpener;
 
-      layerUpdator.Successor = layerAnalyzerProcessor;
+      layerOpener.Successor = layerReseeder;
+
+      layerReseeder.Successor = layerAnalyzerProcessor;
 
       layerAnalyzerProcessor.Operator = layerAnalyzerPlaceholder;
@@ -160,98 +159,4 @@
       termination.ContinueBranch = matingPoolCreator;
     }
-
-    private GeneticAlgorithmMainLoop CreatePreparedGeneticAlgorithmMainLoop() {
-      var mainLoop = new GeneticAlgorithmMainLoop();
-
-      var oldInitialOp = mainLoop.OperatorGraph.InitialOperator;
-      var selector = mainLoop.OperatorGraph.Iterate().OfType<Placeholder>().First(o => o.OperatorParameter.ActualName == "Selector");
-      var crossover = mainLoop.OperatorGraph.Iterate().OfType<Placeholder>().First(o => o.OperatorParameter.ActualName == "Crossover");
-      var subScopesCounter = mainLoop.OperatorGraph.Iterate().OfType<SubScopesCounter>().First();
-      var elitesMerger = mainLoop.OperatorGraph.Iterate().OfType<MergingReducer>().First();
-
-      // Operator starts with calculating number of selected scopes base on plus/comma-selection replacement scheme
-      var numberOfSubScopesBranch = new ConditionalBranch() { Name = "PlusSelection?" };
-      var numberOfSelectedSubScopesPlusCalculator = new ExpressionCalculator() { Name = "NumberOfSelectedSubScopes = PopulationSize * 2" };
-      var numberOfSelectedSubScopesCalculator = new ExpressionCalculator() { Name = "NumberOfSelectedSubScopes = (PopulationSize - Elites) * 2" };
-      var replacementBranch = new ConditionalBranch() { Name = "PlusSelection?" };
-
-      // Set new initial operator
-      mainLoop.OperatorGraph.InitialOperator = numberOfSubScopesBranch;
-
-      numberOfSubScopesBranch.ConditionParameter.ActualName = "PlusSelection";
-      numberOfSubScopesBranch.TrueBranch = numberOfSelectedSubScopesPlusCalculator;
-      numberOfSubScopesBranch.FalseBranch = numberOfSelectedSubScopesCalculator;
-      numberOfSubScopesBranch.Successor = selector;
-
-      numberOfSelectedSubScopesPlusCalculator.CollectedValues.Add(new LookupParameter<IntValue>("PopulationSize"));
-      numberOfSelectedSubScopesPlusCalculator.ExpressionResultParameter.ActualName = "NumberOfSelectedSubScopes";
-      numberOfSelectedSubScopesPlusCalculator.ExpressionParameter.Value = new StringValue("PopulationSize 2 * toint");
-
-      numberOfSelectedSubScopesCalculator.CollectedValues.Add(new LookupParameter<IntValue>("PopulationSize"));
-      numberOfSelectedSubScopesCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Elites"));
-      numberOfSelectedSubScopesCalculator.ExpressionResultParameter.ActualName = "NumberOfSelectedSubScopes";
-      numberOfSelectedSubScopesCalculator.ExpressionParameter.Value = new StringValue("PopulationSize Elites - 2 * toint");
-
-      // Use Elitism or Plus-Selection as replacement strategy
-      var selectedProcessor = (SubScopesProcessor)selector.Successor;
-      var elitismReplacement = selectedProcessor.Successor;
-      selectedProcessor.Successor = replacementBranch;
-      replacementBranch.ConditionParameter.ActualName = "PlusSelection";
-      replacementBranch.FalseBranch = elitismReplacement;
-
-      // Plus selection replacement
-      var replacementMergingReducer = new MergingReducer();
-      var replacementBestSelector = new BestSelector();
-      var replacementRightReducer = new RightReducer();
-      replacementBranch.TrueBranch = replacementMergingReducer;
-
-      replacementMergingReducer.Successor = replacementBestSelector;
-
-      replacementBestSelector.NumberOfSelectedSubScopesParameter.ActualName = "PopulationSize";
-      replacementBestSelector.CopySelected = new BoolValue(false);
-      replacementBestSelector.Successor = replacementRightReducer;
-
-      replacementRightReducer.Successor = null;
-
-      // Increment ages of all individuals after replacement
-      var incrementAgeProcessor = new UniformSubScopesProcessor();
-      var ageIncrementor = new DoubleCounter() { Name = "Increment Age" };
-      replacementBranch.Successor = incrementAgeProcessor;
-      incrementAgeProcessor.Operator = ageIncrementor;
-      incrementAgeProcessor.Successor = null;
-      ageIncrementor.ValueParameter.ActualName = "Age";
-      ageIncrementor.Increment = new DoubleValue(1.0);
-
-      // Insert AgeCalculator between crossover and its successor
-      var crossoverSuccessor = crossover.Successor;
-      var ageCalculator = new WeightingReducer() { Name = "Calculate Age" };
-      crossover.Successor = ageCalculator;
-
-      ageCalculator.ParameterToReduce.ActualName = "Age";
-      ageCalculator.TargetParameter.ActualName = "Age";
-      ageCalculator.WeightParameter.ActualName = "AgeInheritance";
-      ageCalculator.Successor = crossoverSuccessor;
-
-      // When counting the evaluated solutions, write in LayerEvaluatedSolutions
-      subScopesCounter.ValueParameter.ActualName = "LayerEvaluatedSolutions";
-      subScopesCounter.AccumulateParameter.Value = new BoolValue(false);
-
-      // Instead of generational loop after merging of elites, stop
-      elitesMerger.Successor = null;
-
-      // Parameterize
-      foreach (var stochasticOperator in mainLoop.OperatorGraph.Iterate().OfType<IStochasticOperator>())
-        stochasticOperator.RandomParameter.ActualName = "LocalRandom";
-      foreach (var stochasticBranch in mainLoop.OperatorGraph.Iterate().OfType<StochasticBranch>())
-        stochasticBranch.RandomParameter.ActualName = "LocalRandom";
-
-      // Remove unused operators
-      var usedOperators = mainLoop.OperatorGraph.Iterate();
-      var unusedOperators = mainLoop.OperatorGraph.Operators.Except(usedOperators);
-      foreach (var op in unusedOperators.ToList())
-        mainLoop.OperatorGraph.Operators.Remove(op);
-
-      return mainLoop;
-    }
   }
 }
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainOperator.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainOperator.cs	(revision 13095)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainOperator.cs	(revision 13095)
@@ -0,0 +1,126 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Algorithms.GeneticAlgorithm;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  public static class AlpsGeneticAlgorithmMainOperator {
+    public static GeneticAlgorithmMainLoop Create() {
+      var mainLoop = new GeneticAlgorithmMainLoop();
+
+      var selector = mainLoop.OperatorGraph.Iterate().OfType<Placeholder>().First(o => o.OperatorParameter.ActualName == "Selector");
+      var crossover = mainLoop.OperatorGraph.Iterate().OfType<Placeholder>().First(o => o.OperatorParameter.ActualName == "Crossover");
+      var subScopesCounter = mainLoop.OperatorGraph.Iterate().OfType<SubScopesCounter>().First();
+      var elitesMerger = mainLoop.OperatorGraph.Iterate().OfType<MergingReducer>().First();
+
+      // Operator starts with calculating number of selected scopes base on plus/comma-selection replacement scheme
+      var numberOfSubScopesBranch = new ConditionalBranch() { Name = "PlusSelection?" };
+      var numberOfSelectedSubScopesPlusCalculator = new ExpressionCalculator() { Name = "NumberOfSelectedSubScopes = PopulationSize * 2" };
+      var numberOfSelectedSubScopesCalculator = new ExpressionCalculator() { Name = "NumberOfSelectedSubScopes = (PopulationSize - Elites) * 2" };
+      var replacementBranch = new ConditionalBranch() { Name = "PlusSelection?" };
+
+      // Set new initial operator
+      mainLoop.OperatorGraph.InitialOperator = numberOfSubScopesBranch;
+
+      numberOfSubScopesBranch.ConditionParameter.ActualName = "PlusSelection";
+      numberOfSubScopesBranch.TrueBranch = numberOfSelectedSubScopesPlusCalculator;
+      numberOfSubScopesBranch.FalseBranch = numberOfSelectedSubScopesCalculator;
+      numberOfSubScopesBranch.Successor = selector;
+
+      numberOfSelectedSubScopesPlusCalculator.CollectedValues.Add(new LookupParameter<IntValue>("PopulationSize"));
+      numberOfSelectedSubScopesPlusCalculator.ExpressionResultParameter.ActualName = "NumberOfSelectedSubScopes";
+      numberOfSelectedSubScopesPlusCalculator.ExpressionParameter.Value = new StringValue("PopulationSize 2 * toint");
+
+      numberOfSelectedSubScopesCalculator.CollectedValues.Add(new LookupParameter<IntValue>("PopulationSize"));
+      numberOfSelectedSubScopesCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Elites"));
+      numberOfSelectedSubScopesCalculator.ExpressionResultParameter.ActualName = "NumberOfSelectedSubScopes";
+      numberOfSelectedSubScopesCalculator.ExpressionParameter.Value = new StringValue("PopulationSize Elites - 2 * toint");
+
+      // Use Elitism or Plus-Selection as replacement strategy
+      var selectedProcessor = (SubScopesProcessor)selector.Successor;
+      var elitismReplacement = selectedProcessor.Successor;
+      selectedProcessor.Successor = replacementBranch;
+      replacementBranch.ConditionParameter.ActualName = "PlusSelection";
+      replacementBranch.FalseBranch = elitismReplacement;
+
+      // Plus selection replacement
+      var replacementMergingReducer = new MergingReducer();
+      var replacementBestSelector = new BestSelector();
+      var replacementRightReducer = new RightReducer();
+      replacementBranch.TrueBranch = replacementMergingReducer;
+
+      replacementMergingReducer.Successor = replacementBestSelector;
+
+      replacementBestSelector.NumberOfSelectedSubScopesParameter.ActualName = "PopulationSize";
+      replacementBestSelector.CopySelected = new BoolValue(false);
+      replacementBestSelector.Successor = replacementRightReducer;
+
+      replacementRightReducer.Successor = null;
+
+      // Increment ages of all individuals after replacement
+      var incrementAgeProcessor = new UniformSubScopesProcessor();
+      var ageIncrementor = new DoubleCounter() { Name = "Increment Age" };
+      replacementBranch.Successor = incrementAgeProcessor;
+      incrementAgeProcessor.Operator = ageIncrementor;
+      incrementAgeProcessor.Successor = null;
+      ageIncrementor.ValueParameter.ActualName = "Age";
+      ageIncrementor.Increment = new DoubleValue(1.0);
+
+      // Insert AgeCalculator between crossover and its successor
+      var crossoverSuccessor = crossover.Successor;
+      var ageCalculator = new WeightingReducer() { Name = "Calculate Age" };
+      crossover.Successor = ageCalculator;
+
+      ageCalculator.ParameterToReduce.ActualName = "Age";
+      ageCalculator.TargetParameter.ActualName = "Age";
+      ageCalculator.WeightParameter.ActualName = "AgeInheritance";
+      ageCalculator.Successor = crossoverSuccessor;
+
+      // When counting the evaluated solutions, write in LayerEvaluatedSolutions
+      subScopesCounter.ValueParameter.ActualName = "LayerEvaluatedSolutions";
+      subScopesCounter.AccumulateParameter.Value = new BoolValue(false);
+
+      // Instead of generational loop after merging of elites, stop
+      elitesMerger.Successor = null;
+
+      // Parameterize
+      foreach (var stochasticOperator in mainLoop.OperatorGraph.Iterate().OfType<IStochasticOperator>())
+        stochasticOperator.RandomParameter.ActualName = "LocalRandom";
+      foreach (var stochasticBranch in mainLoop.OperatorGraph.Iterate().OfType<StochasticBranch>())
+        stochasticBranch.RandomParameter.ActualName = "LocalRandom";
+
+      // Remove unused operators
+      var usedOperators = mainLoop.OperatorGraph.Iterate();
+      var unusedOperators = mainLoop.OperatorGraph.Operators.Except(usedOperators);
+      foreach (var op in unusedOperators.ToList())
+        mainLoop.OperatorGraph.Operators.Remove(op);
+
+      return mainLoop;
+    }
+  }
+}
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj	(revision 13092)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj	(revision 13095)
@@ -132,4 +132,7 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AlpsGeneticAlgorithmMainOperator.cs" />
+    <Compile Include="LayerOpener.cs" />
+    <Compile Include="LayerReseeder.cs" />
     <Compile Include="WeightingReducer.cs" />
     <Compile Include="Analyzers\OldestAverageYoungestAgeAnalyzer.cs" />
@@ -142,6 +145,4 @@
     <Compile Include="EldersSelector.cs" />
     <Compile Include="LayerCreator.cs" />
-    <Compile Include="LayerSorter.cs" />
-    <Compile Include="LayerUpdator.cs" />
     <Compile Include="MatingPoolCreator.cs" />
     <Compile Include="Plugin.cs" />
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerCreator.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerCreator.cs	(revision 13092)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerCreator.cs	(revision 13095)
@@ -38,4 +38,12 @@
       get { return (ILookupParameter<IntValue>)Parameters["OpenLayers"]; }
     }
+    public OperatorParameter NewLayerOperatorParameter {
+      get { return (OperatorParameter)Parameters["NewLayerOperator"]; }
+    }
+
+    public IOperator NewLayerOperator {
+      get { return NewLayerOperatorParameter.Value; }
+      set { NewLayerOperatorParameter.Value = value; }
+    }
 
     [StorableConstructor]
@@ -48,4 +56,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IntValue>("OpenLayers"));
+      Parameters.Add(new OperatorParameter("NewLayerOperator"));
     }
 
@@ -55,29 +64,30 @@
 
     public override IOperation Apply() {
-      var scopes = ExecutionContext.Scope.SubScopes;
-      if (scopes.Count < 1)
-        throw new ArgumentException("At least one sub-scope must exist.");
+      var layersScope = ExecutionContext.Scope.SubScopes;
+      if (layersScope.Count < 1)
+        throw new ArgumentException("At least one layer must exist.");
 
-      var lastSubScope = scopes.Last();
-      var clone = (IScope)lastSubScope.Clone(new Cloner());
+      var newLayer = (IScope)layersScope.Last().Clone();
 
       int number;
-      if (int.TryParse(clone.Name, out number))
-        clone.Name = (number + 1).ToString();
+      if (int.TryParse(newLayer.Name, out number))
+        newLayer.Name = (number + 1).ToString();
 
-      scopes.Add(clone);
+      layersScope.Add(newLayer);
 
-      // Set new layernumber
-      clone.Variables["Layer"].Value = new IntValue(OpenLayersParameter.ActualValue.Value);
+      // Set new layer number
+      newLayer.Variables["Layer"].Value = new IntValue(OpenLayersParameter.ActualValue.Value);
 
       // Decrement ages, because MainOperator is goint to increment it
-      foreach (var solution in clone.SubScopes)
+      foreach (var solution in newLayer.SubScopes)
         ((DoubleValue)solution.Variables["Age"].Value).Value -= 1;
 
       // Reset existing values in the results to NaN to symbolize that no layer existed during that duration
-      var results = (ResultCollection)clone.Variables["LayerResults"].Value;
+      var results = (ResultCollection)newLayer.Variables["LayerResults"].Value;
       ResetResults(results);
 
-      return base.Apply();
+      var next = new OperationCollection(base.Apply());
+      next.Insert(0, ExecutionContext.CreateChildOperation(NewLayerOperator, newLayer));
+      return next;
     }
 
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerOpener.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerOpener.cs	(revision 13095)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerOpener.cs	(revision 13095)
@@ -0,0 +1,95 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+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;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("LayerOpener", "")]
+  [StorableClass]
+  public sealed class LayerOpener : AlgorithmOperator {
+    [StorableConstructor]
+    private LayerOpener(bool deserializing)
+      : base(deserializing) { }
+    private LayerOpener(LayerOpener original, Cloner cloner)
+      : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LayerOpener(this, cloner);
+    }
+
+    public LayerOpener()
+      : base() {
+      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 LayerCreator() { Name = "Create Layer" };
+      var createChildrenViaCrossover = AlpsGeneticAlgorithmMainOperator.Create();
+      var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
+      var incrOpenLayers = new IntCounter() { Name = "Incr. OpenLayers" };
+      var newLayerResultsCollector = new ResultsCollector() { Name = "Collect new Layer Results" };
+
+      OperatorGraph.InitialOperator = maxLayerReached;
+
+      maxLayerReached.LeftSideParameter.ActualName = "OpenLayers";
+      maxLayerReached.RightSideParameter.ActualName = "NumberOfLayers";
+      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>("AgeLimits"));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("NumberOfLayers"));
+      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 = createChildrenViaCrossover;
+      layerCreator.Successor = incrOpenLayers;
+
+      createChildrenViaCrossover.Successor = incrEvaluatedSolutionsForNewLayer;
+
+      incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = "EvaluatedSolutions";
+      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;
+    }
+  }
+}
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerReseeder.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerReseeder.cs	(revision 13095)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerReseeder.cs	(revision 13095)
@@ -0,0 +1,179 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Drawing;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("LayerReseeder", "")]
+  [StorableClass]
+  public sealed class LayerReseeder : SingleSuccessorOperator, IOperatorGraphOperator {
+    public static new Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Module; }
+    }
+    public override Image ItemImage {
+      get {
+        if (Breakpoint) return HeuristicLab.Common.Resources.VSImageLibrary.BreakpointActive;
+        else return base.ItemImage;
+      }
+    }
+
+    private ILookupParameter<BoolValue> ContinuousReseedingParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["ContinuousReseeding"]; }
+    }
+    private ILookupParameter<IntValue> GenerationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Generations"]; }
+    }
+    private ILookupParameter<IntValue> AgeGapParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["AgeGap"]; }
+    }
+
+    [Storable]
+    private OperatorGraph operatorGraph;
+    public OperatorGraph OperatorGraph {
+      get { return operatorGraph; }
+    }
+
+    [StorableConstructor]
+    private LayerReseeder(bool deserializing)
+      : base(deserializing) { }
+
+    private LayerReseeder(LayerReseeder original, Cloner cloner)
+      : base(original, cloner) {
+      operatorGraph = cloner.Clone(original.operatorGraph);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LayerReseeder(this, cloner);
+    }
+
+    public LayerReseeder()
+      : base() {
+      Parameters.Add(new LookupParameter<BoolValue>("ContinuousReseeding"));
+      Parameters.Add(new LookupParameter<IntValue>("Generations"));
+      Parameters.Add(new LookupParameter<IntValue>("AgeGap"));
+
+      operatorGraph = new OperatorGraph();
+
+      var subScopesCounter = new SubScopesCounter();
+      //var continuousReseedingBranch = new ConditionalBranch() { Name = "ContinuousReseeding?" };
+      //var reseedingIntervalCalculator = new ExpressionCalculator() { Name = "DoReseeding = Generation % AgeGap == 0" };
+      //var doReseedingBranch = new ConditionalBranch() { Name = "DoReseeding?" };
+      var numberOfReplacedCalculator = new ExpressionCalculator() { Name = "NumberOfReplaced = if ContinuousReseeding then max(LayerPopulationSize - (PopulationSize - PopulationSize / AgeGap), 0) else PopulationSize" };
+      var numberOfNewIndividualsCalculator = new ExpressionCalculator() { Name = "NumberOfNewIndividuals = PopulationSize - (LayerPopulatioSize - NumberOfReplaced)" };
+      var oldestSelector = new BestSelector();
+      var processOldest = new SubScopesProcessor();
+      var removeIndividuals = new SubScopesRemover();
+      var createIndividuals = new SolutionsCreator();
+      var mergeIndididuals = new MergingReducer();
+      var initializeAgeProsessor = new UniformSubScopesProcessor();
+      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
+      var incrEvaluatedSolutionsAfterReseeding = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
+      var subScopesCounter2 = new SubScopesCounter();
+
+      //OperatorGraph.InitialOperator = continuousReseedingBranch;
+      OperatorGraph.InitialOperator = subScopesCounter;
+
+      subScopesCounter.ValueParameter.ActualName = "LayerPopulationSize";
+      subScopesCounter.AccumulateParameter.Value = new BoolValue(false);
+      subScopesCounter.Successor = numberOfReplacedCalculator;
+
+      //continuousReseedingBranch.ConditionParameter.ActualName = "ContinuousReseeding";
+      //continuousReseedingBranch.TrueBranch = numberOfChildrenCalculator;
+      //continuousReseedingBranch.FalseBranch = reseedingIntervalCalculator;
+
+      //reseedingIntervalCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Generation"));
+      //reseedingIntervalCalculator.CollectedValues.Add(new LookupParameter<IntValue>("AgeGap"));
+      //reseedingIntervalCalculator.ExpressionResultParameter.ActualName = "DoReseeding";
+      //reseedingIntervalCalculator.ExpressionParameter.Value = new StringValue("Generation AgeGap % 0 ==");
+      //reseedingIntervalCalculator.Successor = doReseedingBranch;
+
+      //doReseedingBranch.ConditionParameter.ActualName = "DoReseeding";
+      //doReseedingBranch.TrueBranch = numberOfChildrenCalculator;
+
+      numberOfReplacedCalculator.CollectedValues.Add(new LookupParameter<BoolValue>("ContinuousReseeding"));
+      numberOfReplacedCalculator.CollectedValues.Add(new LookupParameter<IntValue>("LayerPopulationSize"));
+      numberOfReplacedCalculator.CollectedValues.Add(new LookupParameter<IntValue>("PopulationSize"));
+      numberOfReplacedCalculator.CollectedValues.Add(new LookupParameter<IntValue>("AgeGap"));
+      numberOfReplacedCalculator.ExpressionResultParameter.ActualName = "NumberOfReplaced";
+      const string numSelected = "LayerPopulationSize PopulationSize PopulationSize AgeGap / - -";
+      numberOfReplacedCalculator.ExpressionParameter.Value = new StringValue(numSelected + " 0 0 " + numSelected + " < if PopulationSize ContinuousReseeding if toint");
+      numberOfReplacedCalculator.Successor = numberOfNewIndividualsCalculator;
+
+      numberOfNewIndividualsCalculator.CollectedValues.Add(new LookupParameter<IntValue>("PopulationSize"));
+      numberOfNewIndividualsCalculator.CollectedValues.Add(new LookupParameter<IntValue>("NumberOfReplaced"));
+      numberOfNewIndividualsCalculator.CollectedValues.Add(new LookupParameter<IntValue>("LayerPopulationSize"));
+      numberOfNewIndividualsCalculator.ExpressionResultParameter.ActualName = "NumberOfNewIndividuals";
+      numberOfNewIndividualsCalculator.ExpressionParameter.Value = new StringValue("PopulationSize LayerPopulationSize NumberOfReplaced - - toint");
+      numberOfNewIndividualsCalculator.Successor = oldestSelector;
+
+      oldestSelector.QualityParameter.ActualName = "Age";
+      oldestSelector.NumberOfSelectedSubScopesParameter.ActualName = "NumberOfReplaced";
+      oldestSelector.MaximizationParameter.Value = new BoolValue(true);
+      oldestSelector.CopySelected = new BoolValue(false);
+      oldestSelector.Successor = processOldest;
+
+      processOldest.Operators.Add(new EmptyOperator());
+      processOldest.Operators.Add(removeIndividuals);
+      processOldest.Successor = mergeIndididuals;
+
+      removeIndividuals.Successor = createIndividuals;
+
+      createIndividuals.NumberOfSolutionsParameter.ActualName = "NumberOfNewIndividuals";
+      createIndividuals.Successor = initializeAgeProsessor;
+
+      initializeAgeProsessor.Operator = initializeAge;
+      initializeAgeProsessor.Successor = incrEvaluatedSolutionsAfterReseeding;
+
+      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
+      initializeAge.Successor = null;
+
+      incrEvaluatedSolutionsAfterReseeding.ValueParameter.ActualName = "EvaluatedSolutions";
+      incrEvaluatedSolutionsAfterReseeding.AccumulateParameter.Value = new BoolValue(true);
+      incrEvaluatedSolutionsAfterReseeding.Successor = null;
+
+      mergeIndididuals.Successor = subScopesCounter2;
+
+      subScopesCounter2.ValueParameter.ActualName = "LayerPopulationSize";
+      subScopesCounter2.AccumulateParameter.Value = new BoolValue(false);
+    }
+
+    public override IOperation Apply() {
+      bool continuousReseeding = ContinuousReseedingParameter.ActualValue.Value;
+      int generations = GenerationsParameter.ActualValue.Value;
+      int ageGap = AgeGapParameter.ActualValue.Value;
+
+      var next = new OperationCollection(base.Apply());
+      if (continuousReseeding || generations % ageGap == 0) {
+        var layerZeroScope = ExecutionContext.Scope.SubScopes[0];
+        if (operatorGraph.InitialOperator != null)
+          next.Insert(0, ExecutionContext.CreateChildOperation(operatorGraph.InitialOperator, layerZeroScope));
+      }
+      return next;
+    }
+  }
+}
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerSorter.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerSorter.cs	(revision 13092)
+++ 	(revision )
@@ -1,64 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Algorithms.ALPS {
-  [Item("LayerSorter", "")]
-  [StorableClass]
-  public sealed class LayerSorter : SingleSuccessorOperator {
-    private IScopeTreeLookupParameter<IntValue> LayerParameter {
-      get { return (IScopeTreeLookupParameter<IntValue>)Parameters["Layer"]; }
-    }
-
-    [StorableConstructor]
-    private LayerSorter(bool deserializing)
-      : base(deserializing) { }
-    private LayerSorter(LayerSorter original, Cloner cloner)
-      : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new LayerSorter(this, cloner);
-    }
-    public LayerSorter()
-      : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Layer"));
-    }
-
-    public override IOperation Apply() {
-      var layers = ExecutionContext.Scope.SubScopes;
-      layers.Sort(SortLayers);
-
-      return base.Apply();
-    }
-
-    private int SortLayers(IScope x, IScope y) {
-      var lx = (IntValue)x.Variables["Layer"].Value;
-      var ly = (IntValue)y.Variables["Layer"].Value;
-
-      return lx.Value.CompareTo(ly.Value);
-    }
-  }
-}
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerUpdator.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerUpdator.cs	(revision 13092)
+++ 	(revision )
@@ -1,180 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System.Linq;
-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.ALPS {
-  [Item("LayerUpdator", "Operator which manages the reseeding and creation of layers.")]
-  [StorableClass]
-  public sealed class LayerUpdator : AlgorithmOperator {
-
-    public SolutionsCreator SolutionsCreator {
-      get { return OperatorGraph.Iterate().OfType<SolutionsCreator>().First(); }
-    }
-
-    [StorableConstructor]
-    private LayerUpdator(bool deserializing)
-      : base(deserializing) { }
-    private LayerUpdator(LayerUpdator original, Cloner cloner)
-      : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new LayerUpdator(this, cloner);
-    }
-    public LayerUpdator(IOperator mainOperator)
-      : base() {
-      var incGenSlr = new IntCounter() { Name = "Incr. GenerationsSinceLastRefresh" };
-      var genSlrEqAgeGap = new Comparator() { Name = "GenerationsSinceLastRefresh >= AgeGap" };
-      var updateLayersBranch = new ConditionalBranch() { Name = "UpdateLayers?" };
-      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 LayerCreator() { Name = "Create new Layer" };
-      var incrOpenLayers = new IntCounter() { Name = "Incr. OpenLayers" };
-      var newLayerResultsCollector = new ResultsCollector() { Name = "Collect new Layer Results" };
-      var newLayerSelector = new RightSelector();
-      var newLayerProsessor = new SubScopesProcessor() { Name = "NewLayerProcessor" };
-      var newLayerLayerProcessor = new UniformSubScopesProcessor();
-      var newLayerReducer = new MergingReducer();
-      var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
-      var newResultCollectionAssigner = new Assigner() { Name = "Empty Results" };
-      var regenerateLayerZeroSelector = new LeftSelector();
-      var regenerateLayerZeroProsessor = new SubScopesProcessor() { Name = "LayerZeroProcessor" };
-      var regenerateLayerZeroLayerProsessor = new UniformSubScopesProcessor();
-      var regenerateLayerZeroReducer = new MergingReducer();
-      var layerSorter = new LayerSorter();
-      var subScopesRemover = new SubScopesRemover();
-      var solutionsCreator = new SolutionsCreator();
-      var initializeAgeProsessor = new UniformSubScopesProcessor();
-      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
-      var incrEvaluatedSolutionsAfterReseeding = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
-      var resetGenSlr = new Assigner() { Name = "Reset GenerationsSinceLastRefresh" };
-
-      OperatorGraph.InitialOperator = incGenSlr;
-
-      incGenSlr.ValueParameter.ActualName = "GenerationsSinceLastRefresh";
-      incGenSlr.Increment = new IntValue(1);
-      incGenSlr.Successor = genSlrEqAgeGap;
-
-      genSlrEqAgeGap.LeftSideParameter.ActualName = "GenerationsSinceLastRefresh";
-      genSlrEqAgeGap.RightSideParameter.ActualName = "AgeGap";
-      genSlrEqAgeGap.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
-      genSlrEqAgeGap.ResultParameter.ActualName = "UpdateLayers";
-      genSlrEqAgeGap.Successor = updateLayersBranch;
-
-      updateLayersBranch.ConditionParameter.ActualName = "UpdateLayers";
-      updateLayersBranch.TrueBranch = maxLayerReached;
-
-      maxLayerReached.LeftSideParameter.ActualName = "OpenLayers";
-      maxLayerReached.RightSideParameter.ActualName = "NumberOfLayers";
-      maxLayerReached.ResultParameter.ActualName = "MaxLayerReached";
-      maxLayerReached.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
-      maxLayerReached.Successor = maxLayerReachedBranch;
-
-      maxLayerReachedBranch.ConditionParameter.ActualName = "MaxLayerReached";
-      maxLayerReachedBranch.FalseBranch = openNewLayerCalculator;
-      maxLayerReachedBranch.Successor = regenerateLayerZeroSelector;
-
-      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntArray>("AgeLimits"));
-      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
-      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("NumberOfLayers"));
-      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.Successor = newLayerSelector;
-
-      newLayerSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
-      newLayerSelector.CopySelected = new BoolValue(false);
-      newLayerSelector.Successor = newLayerProsessor;
-
-      newLayerProsessor.Operators.Add(new EmptyOperator());
-      newLayerProsessor.Operators.Add(newLayerLayerProcessor);
-      newLayerProsessor.Successor = newLayerReducer;
-
-      newLayerLayerProcessor.Operator = incrEvaluatedSolutionsForNewLayer;
-
-      newLayerReducer.Successor = incrOpenLayers;
-
-      incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = "EvaluatedSolutions";
-      incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
-      incrEvaluatedSolutionsForNewLayer.Successor = mainOperator;
-
-      newResultCollectionAssigner.LeftSideParameter.ActualName = "LayerResults";
-      newResultCollectionAssigner.RightSideParameter.Value = new ResultCollection();
-      newResultCollectionAssigner.Successor = mainOperator;
-      // TODO mainOperator increment age
-
-      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;
-
-      regenerateLayerZeroSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
-      regenerateLayerZeroSelector.CopySelected = new BoolValue(false);
-      regenerateLayerZeroSelector.Successor = regenerateLayerZeroProsessor;
-
-      regenerateLayerZeroProsessor.Operators.Add(new EmptyOperator());
-      regenerateLayerZeroProsessor.Operators.Add(regenerateLayerZeroLayerProsessor);
-      regenerateLayerZeroProsessor.Successor = regenerateLayerZeroReducer;
-
-      regenerateLayerZeroLayerProsessor.Operator = subScopesRemover;
-
-      regenerateLayerZeroReducer.Successor = layerSorter;
-
-      layerSorter.Successor = resetGenSlr;
-
-      subScopesRemover.Successor = solutionsCreator;
-
-      solutionsCreator.Successor = initializeAgeProsessor;
-
-      initializeAgeProsessor.Operator = initializeAge;
-      initializeAgeProsessor.Successor = incrEvaluatedSolutionsAfterReseeding;
-
-      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
-      initializeAge.Successor = null;
-
-      incrEvaluatedSolutionsAfterReseeding.ValueParameter.ActualName = "EvaluatedSolutions";
-      incrEvaluatedSolutionsAfterReseeding.AccumulateParameter.Value = new BoolValue(true);
-      incrEvaluatedSolutionsAfterReseeding.Successor = null;
-
-      resetGenSlr.LeftSideParameter.ActualName = "GenerationsSinceLastRefresh";
-      resetGenSlr.RightSideParameter.Value = new IntValue(0);
-      resetGenSlr.Successor = null;
-    }
-  }
-}
