Index: trunk/sources/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/IslandGeneticAlgorithmMainLoop.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/IslandGeneticAlgorithmMainLoop.cs	(revision 3610)
+++ trunk/sources/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/IslandGeneticAlgorithmMainLoop.cs	(revision 3611)
@@ -171,5 +171,5 @@
       QualityDifferenceCalculator islandQualityDifferenceCalculator2 = new QualityDifferenceCalculator();
       Placeholder islandVisualizer2 = new Placeholder();
-      // END GA mainloop
+      IntCounter generationsCounter = new IntCounter();
       IntCounter generationsSinceLastMigrationCounter = new IntCounter();
       Comparator migrationComparator = new Comparator();
@@ -182,5 +182,4 @@
       UniformSubScopesProcessor uniformSubScopesProcessor4 = new UniformSubScopesProcessor();
       Placeholder immigrationReplacer = new Placeholder();
-      IntCounter generationsCounter = new IntCounter();
       Comparator generationsComparator = new Comparator();
       BestQualityMemorizer bestQualityMemorizer3 = new BestQualityMemorizer();
@@ -272,5 +271,4 @@
       resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
 
-      // START GA mainloop
       selector.Name = "Selector (placeholder)";
       selector.OperatorParameter.ActualName = SelectorParameter.Name;
@@ -321,9 +319,14 @@
       islandVisualizer2.Name = "Visualizer";
       islandVisualizer2.OperatorParameter.ActualName = "Visualizer";
-      // END GA mainloop
-
+
+      generationsCounter.Name = "Generations + 1";
+      generationsCounter.Increment = new IntValue(1);
+      generationsCounter.ValueParameter.ActualName = "Generations";
+
+      generationsSinceLastMigrationCounter.Name = "GenerationsSinceLastMigration + 1";
       generationsSinceLastMigrationCounter.ValueParameter.ActualName = "GenerationsSinceLastMigration";
       generationsSinceLastMigrationCounter.Increment = new IntValue(1);
 
+      migrationComparator.Name = "GenerationsSinceLastMigration = MigrationInterval ?";
       migrationComparator.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
       migrationComparator.Comparison = new Comparison(ComparisonType.Equal);
@@ -331,7 +334,8 @@
       migrationComparator.ResultParameter.ActualName = "Migrate";
 
+      migrationBranch.Name = "Migrate?";
       migrationBranch.ConditionParameter.ActualName = "Migrate";
 
-      resetGenerationsSinceLastMigrationAssigner.Name = "Reset Counter";
+      resetGenerationsSinceLastMigrationAssigner.Name = "Reset GenerationsSinceLastMigration";
       resetGenerationsSinceLastMigrationAssigner.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
       resetGenerationsSinceLastMigrationAssigner.RightSideParameter.Value = new IntValue(0);
@@ -350,8 +354,5 @@
       immigrationReplacer.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
 
-      generationsCounter.Name = "Generations + 1";
-      generationsCounter.Increment = new IntValue(1);
-      generationsCounter.ValueParameter.ActualName = "Generations";
-
+      generationsComparator.Name = "Generations >= MaximumGenerations ?";
       generationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
       generationsComparator.LeftSideParameter.ActualName = "Generations";
@@ -385,4 +386,5 @@
       qualityDifferenceCalculator2.SecondQualityParameter.ActualName = "BestQuality";
 
+      generationsTerminationCondition.Name = "Terminate?";
       generationsTerminationCondition.ConditionParameter.ActualName = "TerminateGenerations";
       #endregion
@@ -406,5 +408,5 @@
       resultsCollector.Successor = uniformSubScopesProcessor1;
       uniformSubScopesProcessor1.Operator = selector;
-      uniformSubScopesProcessor1.Successor = generationsSinceLastMigrationCounter;
+      uniformSubScopesProcessor1.Successor = generationsCounter;
       selector.Successor = subScopesProcessor1;
       subScopesProcessor1.Operators.Add(new EmptyOperator());
@@ -432,9 +434,10 @@
       islandQualityDifferenceCalculator2.Successor = islandVisualizer2;
       islandVisualizer2.Successor = null;
+      generationsCounter.Successor = generationsSinceLastMigrationCounter;
       generationsSinceLastMigrationCounter.Successor = migrationComparator;
       migrationComparator.Successor = migrationBranch;
       migrationBranch.TrueBranch = resetGenerationsSinceLastMigrationAssigner;
       migrationBranch.FalseBranch = null;
-      migrationBranch.Successor = generationsCounter;
+      migrationBranch.Successor = generationsComparator;
       resetGenerationsSinceLastMigrationAssigner.Successor = migrationsCounter;
       migrationsCounter.Successor = uniformSubScopesProcessor3;
@@ -444,5 +447,4 @@
       uniformSubScopesProcessor4.Operator = immigrationReplacer;
       uniformSubScopesProcessor4.Successor = null;
-      generationsCounter.Successor = generationsComparator;
       generationsComparator.Successor = bestQualityMemorizer3;
       bestQualityMemorizer3.Successor = bestQualityMemorizer4;
Index: trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm-3.3.csproj	(revision 3610)
+++ trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm-3.3.csproj	(revision 3611)
@@ -80,4 +80,5 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="OffspringSelectionGeneticAlgorithmMainLoop.cs" />
     <Compile Include="SASEGASA.cs" />
     <Compile Include="SASEGASAMainLoop.cs" />
@@ -86,5 +87,5 @@
     <Compile Include="IslandOffspringSelectionGeneticAlgorithmMainLoop.cs" />
     <Compile Include="OffspringSelectionGeneticAlgorithm.cs" />
-    <Compile Include="OffspringSelectionGeneticAlgorithmMainLoop.cs" />
+    <Compile Include="OffspringSelectionGeneticAlgorithmMainOperator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
Index: trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs	(revision 3610)
+++ trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs	(revision 3611)
@@ -76,12 +76,12 @@
       get { return (ConstrainedValueParameter<ISelector>)Parameters["EmigrantsSelector"]; }
     }
-    private ConstrainedValueParameter<ISelector> ImmigrationSelectorParameter {
-      get { return (ConstrainedValueParameter<ISelector>)Parameters["ImmigrationSelector"]; }
+    private ConstrainedValueParameter<IReplacer> ImmigrationReplacerParameter {
+      get { return (ConstrainedValueParameter<IReplacer>)Parameters["ImmigrationReplacer"]; }
     }
     private ValueParameter<IntValue> PopulationSizeParameter {
       get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
     }
-    private ValueParameter<IntValue> MaximumMigrationsParameter {
-      get { return (ValueParameter<IntValue>)Parameters["MaximumMigrations"]; }
+    private ValueParameter<IntValue> MaximumGenerationsParameter {
+      get { return (ValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
     }
     private ConstrainedValueParameter<ISelector> SelectorParameter {
@@ -152,7 +152,7 @@
       set { EmigrantsSelectorParameter.Value = value; }
     }
-    public ISelector ImmigrationSelector {
-      get { return ImmigrationSelectorParameter.Value; }
-      set { ImmigrationSelectorParameter.Value = value; }
+    public IReplacer ImmigrationReplacer {
+      get { return ImmigrationReplacerParameter.Value; }
+      set { ImmigrationReplacerParameter.Value = value; }
     }
     public IntValue PopulationSize {
@@ -160,7 +160,7 @@
       set { PopulationSizeParameter.Value = value; }
     }
-    public IntValue MaximumMigrations {
-      get { return MaximumMigrationsParameter.Value; }
-      set { MaximumMigrationsParameter.Value = value; }
+    public IntValue MaximumGenerations {
+      get { return MaximumGenerationsParameter.Value; }
+      set { MaximumGenerationsParameter.Value = value; }
     }
     public ISelector Selector {
@@ -218,5 +218,5 @@
     private List<IDiscreteDoubleValueModifier> comparisonFactorModifiers;
     private List<ISelector> emigrantsSelectors;
-    private List<ISelector> immigrationSelectors;
+    private List<IReplacer> immigrationReplacers;
     private List<IMigrator> migrators;
     private RandomCreator RandomCreator {
@@ -245,7 +245,7 @@
       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<ISelector>("ImmigrationSelector", "Selects the population from the unification of the original population and the immigrants."));
+      Parameters.Add(new ConstrainedValueParameter<IReplacer>("ImmigrationReplacer", "Selects the population from the unification of the original population and the immigrants."));
       Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions of each island.", new IntValue(100)));
-      Parameters.Add(new ValueParameter<IntValue>("MaximumMigrations", "The maximum number of migrations that should occur.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations that should be processed.", new IntValue(100)));
       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."));
@@ -287,6 +287,6 @@
 
       mainLoop.EmigrantsSelectorParameter.ActualName = EmigrantsSelectorParameter.Name;
-      mainLoop.ImmigrationSelectorParameter.ActualName = ImmigrationSelectorParameter.Name;
-      mainLoop.MaximumMigrationsParameter.ActualName = MaximumMigrationsParameter.Name;
+      mainLoop.ImmigrationReplacerParameter.ActualName = ImmigrationReplacerParameter.Name;
+      mainLoop.MaximumGenerationsParameter.ActualName = MaximumGenerationsParameter.Name;
       mainLoop.MigrationIntervalParameter.ActualName = MigrationIntervalParameter.Name;
       mainLoop.MigrationRateParameter.ActualName = MigrationRateParameter.Name;
@@ -301,4 +301,5 @@
       mainLoop.ResultsParameter.ActualName = "Results";
       mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+      mainLoop.ComparisonFactorParameter.ActualName = "ComparisonFactor";
       mainLoop.ComparisonFactorLowerBoundParameter.ActualName = ComparisonFactorLowerBoundParameter.Name;
       mainLoop.ComparisonFactorModifierParameter.ActualName = ComparisonFactorModifierParameter.Name;
@@ -392,5 +393,5 @@
     }
     private void MaximumMigrationsParameter_ValueChanged(object sender, EventArgs e) {
-      MaximumMigrations.ValueChanged += new EventHandler(MaximumMigrations_ValueChanged);
+      MaximumGenerations.ValueChanged += new EventHandler(MaximumMigrations_ValueChanged);
       ParameterizeComparisonFactorModifiers();
     }
@@ -424,6 +425,6 @@
       MigrationIntervalParameter.ValueChanged += new EventHandler(MigrationIntervalParameter_ValueChanged);
       MigrationInterval.ValueChanged += new EventHandler(MigrationInterval_ValueChanged);
-      MaximumMigrationsParameter.ValueChanged += new EventHandler(MaximumMigrationsParameter_ValueChanged);
-      MaximumMigrations.ValueChanged += new EventHandler(MaximumMigrations_ValueChanged);
+      MaximumGenerationsParameter.ValueChanged += new EventHandler(MaximumMigrationsParameter_ValueChanged);
+      MaximumGenerations.ValueChanged += new EventHandler(MaximumMigrations_ValueChanged);
       if (Problem != null) {
         UpdateCrossovers();
@@ -455,6 +456,6 @@
       emigrantsSelectors = new List<ISelector>();
       emigrantsSelectors.AddRange(ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name));
-      immigrationSelectors = new List<ISelector>();
-      immigrationSelectors.AddRange(ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name));
+      immigrationReplacers = new List<IReplacer>();
+      immigrationReplacers.AddRange(ApplicationManager.Manager.GetInstances<IReplacer>().OrderBy(x => x.Name));
       ParameterizeSelectors();
     }
@@ -480,7 +481,5 @@
         ParameterizeStochasticOperator(selector);
       }
-      foreach (ISelector selector in immigrationSelectors) {
-        selector.CopySelected = new BoolValue(false);
-        selector.NumberOfSelectedSubScopesParameter.Value = PopulationSize;
+      foreach (IReplacer selector in immigrationReplacers) {
         ParameterizeStochasticOperator(selector);
       }
@@ -494,7 +493,7 @@
           selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
         }
-        foreach (ISingleObjectiveSelector selector in immigrationSelectors.OfType<ISingleObjectiveSelector>()) {
-          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
-          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        foreach (ISingleObjectiveReplacer replacer in immigrationReplacers.OfType<ISingleObjectiveReplacer>()) {
+          replacer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+          replacer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
         }
       }
@@ -503,5 +502,5 @@
       foreach (IDiscreteDoubleValueModifier modifier in comparisonFactorModifiers) {
         modifier.IndexParameter.ActualName = "Generations";
-        modifier.EndIndexParameter.Value = new IntValue(MigrationInterval.Value * MaximumMigrations.Value);
+        modifier.EndIndexParameter.Value = new IntValue(MigrationInterval.Value * MaximumGenerations.Value);
         modifier.EndValueParameter.ActualName = ComparisonFactorUpperBoundParameter.Name;
         modifier.StartIndexParameter.Value = new IntValue(0);
@@ -533,11 +532,11 @@
       }
 
-      oldSelector = ImmigrationSelectorParameter.Value;
-      ImmigrationSelectorParameter.ValidValues.Clear();
-      foreach (ISelector selector in immigrationSelectors)
-        ImmigrationSelectorParameter.ValidValues.Add(selector);
+      IReplacer oldReplacer = ImmigrationReplacerParameter.Value;
+      ImmigrationReplacerParameter.ValidValues.Clear();
+      foreach (IReplacer replacer in immigrationReplacers)
+        ImmigrationReplacerParameter.ValidValues.Add(replacer);
       if (oldSelector != null) {
-        ISelector selector = ImmigrationSelectorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldSelector.GetType());
-        if (selector != null) ImmigrationSelectorParameter.Value = selector;
+        IReplacer replacer = ImmigrationReplacerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldSelector.GetType());
+        if (replacer != null) ImmigrationReplacerParameter.Value = replacer;
       }
     }
Index: trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithmMainLoop.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithmMainLoop.cs	(revision 3610)
+++ trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithmMainLoop.cs	(revision 3611)
@@ -70,12 +70,12 @@
       get { return (ValueLookupParameter<IOperator>)Parameters["EmigrantsSelector"]; }
     }
-    public ValueLookupParameter<IOperator> ImmigrationSelectorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["ImmigrationSelector"]; }
+    public ValueLookupParameter<IOperator> ImmigrationReplacerParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["ImmigrationReplacer"]; }
     }
     public ValueLookupParameter<IntValue> PopulationSizeParameter {
       get { return (ValueLookupParameter<IntValue>)Parameters["PopulationSize"]; }
     }
-    public ValueLookupParameter<IntValue> MaximumMigrationsParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumMigrations"]; }
+    public ValueLookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
     }
     public ValueLookupParameter<IOperator> SelectorParameter {
@@ -108,4 +108,7 @@
     public ValueLookupParameter<DoubleValue> SuccessRatioParameter {
       get { return (ValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
+    }
+    public LookupParameter<DoubleValue> ComparisonFactorParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["ComparisonFactor"]; }
     }
     public ValueLookupParameter<DoubleValue> ComparisonFactorLowerBoundParameter {
@@ -140,7 +143,7 @@
       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>("ImmigrationSelector", "Selects the population from the unification of the original population and the immigrants."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("ImmigrationReplacer", "Replaces part 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>("MaximumMigrations", "The maximum number of migrations after which the operator should terminate."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations that should be processed."));
       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."));
@@ -153,4 +156,5 @@
       Parameters.Add(new LookupParameter<IItem>("Visualization", "The item which represents the visualization of solutions."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
+      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>("ComparisonFactorLowerBound", "The lower bound of the comparison factor (start)."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorUpperBound", "The upper bound of the comparison factor (end)."));
@@ -162,57 +166,125 @@
       #region Create operators
       VariableCreator variableCreator = new VariableCreator();
-      UniformSubScopesProcessor ussp0 = new UniformSubScopesProcessor();
+      UniformSubScopesProcessor uniformSubScopesProcessor0 = new UniformSubScopesProcessor();
       VariableCreator islandVariableCreator = new VariableCreator();
-      Assigner islandVariableAssigner = new Assigner();
+      BestQualityMemorizer islandBestQualityMemorizer1 = new BestQualityMemorizer();
+      BestAverageWorstQualityCalculator islandBestAverageWorstQualityCalculator1 = new BestAverageWorstQualityCalculator();
+      DataTableValuesCollector islandDataTableValuesCollector1 = new DataTableValuesCollector();
+      DataTableValuesCollector islandDataTableValuesCollector2 = new DataTableValuesCollector();
+      QualityDifferenceCalculator islandQualityDifferenceCalculator1 = new QualityDifferenceCalculator();
+      Placeholder islandVisualizer1 = new Placeholder();
+      ResultsCollector islandResultsCollector = new ResultsCollector();
       BestQualityMemorizer bestQualityMemorizer1 = new BestQualityMemorizer();
+      BestQualityMemorizer bestQualityMemorizer2 = new BestQualityMemorizer();
       BestAverageWorstQualityCalculator bestAverageWorstQualityCalculator1 = new BestAverageWorstQualityCalculator();
-      BestQualityMemorizer bestQualityMemorizer2 = new BestQualityMemorizer();
-      BestAverageWorstQualityCalculator bestAverageWorstQualityCalculator2 = new BestAverageWorstQualityCalculator();
       DataTableValuesCollector dataTableValuesCollector1 = new DataTableValuesCollector();
+      DataTableValuesCollector dataTableValuesCollector2 = new DataTableValuesCollector();
       QualityDifferenceCalculator qualityDifferenceCalculator1 = new QualityDifferenceCalculator();
       ResultsCollector resultsCollector = new ResultsCollector();
-      UniformSubScopesProcessor ussp1 = new UniformSubScopesProcessor();
-      OffspringSelectionGeneticAlgorithmMainLoop mainLoop = new OffspringSelectionGeneticAlgorithmMainLoop();
+      Placeholder comparisonFactorModifier = new Placeholder();
+      UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
+      ConditionalBranch islandTerminatedBySelectionPressure1 = new ConditionalBranch();
+      OffspringSelectionGeneticAlgorithmMainOperator mainOperator = new OffspringSelectionGeneticAlgorithmMainOperator();
+      BestQualityMemorizer islandBestQualityMemorizer2 = new BestQualityMemorizer();
+      BestAverageWorstQualityCalculator islandBestAverageWorstQualityCalculator2 = new BestAverageWorstQualityCalculator();
+      DataTableValuesCollector islandDataTableValuesCollector3 = new DataTableValuesCollector();
+      DataTableValuesCollector islandDataTableValuesCollector4 = new DataTableValuesCollector();
+      QualityDifferenceCalculator islandQualityDifferenceCalculator2 = new QualityDifferenceCalculator();
+      Placeholder islandVisualizer2 = new Placeholder();
+      IntCounter islandEvaluatedSolutionsCounter = new IntCounter();
+      Comparator islandSelectionPressureComparator = new Comparator();
+      ConditionalBranch islandTerminatedBySelectionPressure2 = new ConditionalBranch();
+      IntCounter terminatedIslandsCounter = new IntCounter();
+      IntCounter generationsCounter = new IntCounter();
+      IntCounter generationsSinceLastMigrationCounter = new IntCounter();
+      Comparator migrationComparator = new Comparator();
+      ConditionalBranch migrationBranch = new ConditionalBranch();
+      Assigner resetTerminatedIslandsAssigner = new Assigner();
+      Assigner resetGenerationsSinceLastMigrationAssigner = new Assigner();
+      IntCounter migrationsCounter = new IntCounter();
+      UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
+      Assigner reviveIslandAssigner = new Assigner();
       Placeholder emigrantsSelector = new Placeholder();
       Placeholder migrator = new Placeholder();
-      UniformSubScopesProcessor ussp2 = new UniformSubScopesProcessor();
-      IntCounter maximumGenerationsCounter = new IntCounter();
-      MergingReducer mergingReducer = new MergingReducer();
-      Placeholder immigrationSelector = new Placeholder();
-      RightReducer rightReducer = new RightReducer();
-      IntCounter migrationsCounter = new IntCounter();
-      Comparator maxMigrationsComparator = new Comparator();
+      UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
+      Placeholder immigrationReplacer = new Placeholder();
+      Comparator generationsComparator = new Comparator();
+      Comparator terminatedIslandsComparator = new Comparator();
       BestQualityMemorizer bestQualityMemorizer3 = new BestQualityMemorizer();
-      BestAverageWorstQualityCalculator bestAverageWorstQualityCalculator3 = new BestAverageWorstQualityCalculator();
-      DataTableValuesCollector dataTableValuesCollector2 = new DataTableValuesCollector();
+      BestQualityMemorizer bestQualityMemorizer4 = new BestQualityMemorizer();
+      BestAverageWorstQualityCalculator bestAverageWorstQualityCalculator2 = new BestAverageWorstQualityCalculator();
+      DataTableValuesCollector dataTableValuesCollector3 = new DataTableValuesCollector();
+      DataTableValuesCollector dataTableValuesCollector4 = new DataTableValuesCollector();
       QualityDifferenceCalculator qualityDifferenceCalculator2 = new QualityDifferenceCalculator();
-      ConditionalBranch migrationTerminationCondition = new ConditionalBranch();
+      ConditionalBranch generationsTerminationCondition = new ConditionalBranch();
+      ConditionalBranch terminatedIslandsCondition = new ConditionalBranch();
 
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Migrations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("GenerationsSinceLastMigration", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("TerminatedIslands", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(0)));
+
+      islandVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("IslandResults", new ResultCollection()));
+      islandVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("IslandEvaluatedSolutions", new IntValue(0)));
+      islandVariableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("TerminateSelectionPressure", new BoolValue(false)));
+      islandVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
+
+      islandBestQualityMemorizer1.BestQualityParameter.ActualName = "BestQuality";
+      islandBestQualityMemorizer1.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      islandBestQualityMemorizer1.QualityParameter.ActualName = QualityParameter.Name;
+
+      islandBestAverageWorstQualityCalculator1.AverageQualityParameter.ActualName = "CurrentAverageQuality";
+      islandBestAverageWorstQualityCalculator1.BestQualityParameter.ActualName = "CurrentBestQuality";
+      islandBestAverageWorstQualityCalculator1.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      islandBestAverageWorstQualityCalculator1.QualityParameter.ActualName = QualityParameter.Name;
+      islandBestAverageWorstQualityCalculator1.WorstQualityParameter.ActualName = "CurrentWorstQuality";
       
-      islandVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("IslandResults", new ResultCollection()));
-
-      islandVariableAssigner.LeftSideParameter.ActualName = "MaximumGenerations";
-      islandVariableAssigner.RightSideParameter.ActualName = "MigrationInterval";
+      islandDataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best BestQuality", null, "CurrentBestBestQuality"));
+      islandDataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Average BestQuality", null, "CurrentAverageBestQuality"));
+      islandDataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Worst BestQuality", null, "CurrentWorstBestQuality"));
+      islandDataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
+      islandDataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Known Quality", null, BestKnownQualityParameter.Name));
+      islandDataTableValuesCollector1.DataTableParameter.ActualName = "BestQualities";
+
+      islandDataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Selection Pressure", null, "SelectionPressure"));
+      islandDataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Maximum Selection Pressure", null, MaximumSelectionPressureParameter.Name));
+      islandDataTableValuesCollector2.DataTableParameter.ActualName = "SelectionPressures";
+
+      islandQualityDifferenceCalculator1.AbsoluteDifferenceParameter.ActualName = "AbsoluteDifferenceBestKnownToBest";
+      islandQualityDifferenceCalculator1.FirstQualityParameter.ActualName = BestKnownQualityParameter.Name;
+      islandQualityDifferenceCalculator1.RelativeDifferenceParameter.ActualName = "RelativeDifferenceBestKnownToBest";
+      islandQualityDifferenceCalculator1.SecondQualityParameter.ActualName = "BestQuality";
+
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best Quality", null, "CurrentBestQuality"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Average Quality", null, "CurrentAverageQuality"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Worst Quality", null, "CurrentWorstQuality"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Known Quality", null, BestKnownQualityParameter.Name));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Absolute Difference of Best Known Quality to Best Quality", null, "AbsoluteDifferenceBestKnownToBest"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Relative Difference of Best Known Quality to Best Quality", null, "RelativeDifferenceBestKnownToBest"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "IslandEvaluatedSolutions"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Curent Comparison Factor", null, "ComparisonFactor"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", null, "SelectionPressure"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", null, "CurrentSuccessRatio"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<IItem>("Solution Visualization", null, VisualizationParameter.Name));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("Qualities"));
+      islandResultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("SelectionPressures"));
+      islandResultsCollector.ResultsParameter.ActualName = "IslandResults";
 
       bestQualityMemorizer1.BestQualityParameter.ActualName = "BestQuality";
       bestQualityMemorizer1.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      bestQualityMemorizer1.QualityParameter.ActualName = QualityParameter.Name;
-
-      bestAverageWorstQualityCalculator1.AverageQualityParameter.ActualName = "CurrentAverageQuality";
-      bestAverageWorstQualityCalculator1.BestQualityParameter.ActualName = "CurrentBestQuality";
-      bestAverageWorstQualityCalculator1.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      bestAverageWorstQualityCalculator1.QualityParameter.ActualName = QualityParameter.Name;
-      bestAverageWorstQualityCalculator1.WorstQualityParameter.ActualName = "CurrentWorstQuality";
-
-      bestQualityMemorizer2.BestQualityParameter.ActualName = "BestQuality";
+      bestQualityMemorizer1.QualityParameter.ActualName = "BestQuality";
+
+      bestQualityMemorizer2.BestQualityParameter.ActualName = BestKnownQualityParameter.Name;
       bestQualityMemorizer2.MaximizationParameter.ActualName = MaximizationParameter.Name;
       bestQualityMemorizer2.QualityParameter.ActualName = "BestQuality";
 
-      bestAverageWorstQualityCalculator2.AverageQualityParameter.ActualName = "CurrentAverageBestQuality";
-      bestAverageWorstQualityCalculator2.BestQualityParameter.ActualName = "CurrentBestBestQuality";
-      bestAverageWorstQualityCalculator2.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      bestAverageWorstQualityCalculator2.QualityParameter.ActualName = "CurrentBestQuality";
-      bestAverageWorstQualityCalculator2.WorstQualityParameter.ActualName = "CurrentWorstBestQuality";
+      bestAverageWorstQualityCalculator1.AverageQualityParameter.ActualName = "CurrentAverageBestQuality";
+      bestAverageWorstQualityCalculator1.BestQualityParameter.ActualName = "CurrentBestBestQuality";
+      bestAverageWorstQualityCalculator1.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      bestAverageWorstQualityCalculator1.QualityParameter.ActualName = "CurrentBestQuality";
+      bestAverageWorstQualityCalculator1.WorstQualityParameter.ActualName = "CurrentWorstBestQuality";
 
       dataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best BestQuality", null, "CurrentBestBestQuality"));
@@ -223,4 +295,8 @@
       dataTableValuesCollector1.DataTableParameter.ActualName = "BestQualities";
 
+      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Maximum Selection Pressure", null, MaximumSelectionPressureParameter.Name));
+      dataTableValuesCollector2.CollectedValues.Add(new SubScopesLookupParameter<DoubleValue>("Selection Pressure Island", null, "SelectionPressure"));
+      dataTableValuesCollector2.DataTableParameter.ActualName = "SelectionPressures";
+
       qualityDifferenceCalculator1.AbsoluteDifferenceParameter.ActualName = "AbsoluteDifferenceBestKnownToBest";
       qualityDifferenceCalculator1.FirstQualityParameter.ActualName = BestKnownQualityParameter.Name;
@@ -229,4 +305,6 @@
 
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Migrations"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedSolutions"));
       resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best BestQuality", null, "CurrentBestBestQuality"));
       resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Average BestQuality", null, "CurrentAverageBestQuality"));
@@ -237,40 +315,99 @@
       resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Relative Difference of Best Known Quality to Best Quality", null, "RelativeDifferenceBestKnownToBest"));
       resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("BestQualities"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("SelectionPressures"));
       resultsCollector.CollectedValues.Add(new SubScopesLookupParameter<ResultCollection>("IslandResults", "Result set for each island"));
       resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
 
-      mainLoop.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
-      mainLoop.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      mainLoop.QualityParameter.ActualName = QualityParameter.Name;
-      mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
-      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
-      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
-      mainLoop.MaximumGenerationsParameter.ActualName = "MaximumGenerations";
-      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
-      mainLoop.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
-      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
-      mainLoop.RandomParameter.ActualName = RandomParameter.Name;
-      mainLoop.ResultsParameter.ActualName = "IslandResults";
-      mainLoop.VisualizerParameter.ActualName = VisualizerParameter.Name;
-      mainLoop.VisualizationParameter.ActualName = VisualizationParameter.Name;
-      mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
-      mainLoop.ComparisonFactorLowerBoundParameter.ActualName = ComparisonFactorLowerBoundParameter.Name;
-      mainLoop.ComparisonFactorModifierParameter.ActualName = ComparisonFactorModifierParameter.Name;
-      mainLoop.ComparisonFactorUpperBoundParameter.ActualName = ComparisonFactorUpperBoundParameter.Name;
-      mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
-      mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
-
-      maximumGenerationsCounter.ValueParameter.ActualName = "MaximumGenerations";
-      maximumGenerationsCounter.Increment = null;
-      maximumGenerationsCounter.IncrementParameter.ActualName = "MigrationInterval";
-
-      emigrantsSelector.Name = "Emigrants Selector (placeholder)";
-      emigrantsSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
-
-      migrator.Name = "Migrator (placeholder)";
-      migrator.OperatorParameter.ActualName = MigratorParameter.Name;
-
-      immigrationSelector.Name = "Immigration Selector (placeholder)";
-      immigrationSelector.OperatorParameter.ActualName = ImmigrationSelectorParameter.Name;
+      comparisonFactorModifier.Name = "ComparisonFactorModifier (Placeholder)";
+      comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
+
+      islandTerminatedBySelectionPressure1.Name = "Island Terminated ?";
+      islandTerminatedBySelectionPressure1.ConditionParameter.ActualName = "TerminateSelectionPressure";
+
+      mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
+      mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
+      mainOperator.EvaluatedSolutionsParameter.ActualName = "IslandEvaluatedSolutions";
+      mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
+      mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      mainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      mainOperator.MutatorParameter.ActualName = MutatorParameter.Name;
+      mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
+      mainOperator.QualityParameter.ActualName = QualityParameter.Name;
+      mainOperator.RandomParameter.ActualName = RandomParameter.Name;
+      mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
+      mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
+      mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+
+      islandBestQualityMemorizer2.BestQualityParameter.ActualName = "BestQuality";
+      islandBestQualityMemorizer2.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      islandBestQualityMemorizer2.QualityParameter.ActualName = QualityParameter.Name;
+
+      islandBestAverageWorstQualityCalculator2.AverageQualityParameter.ActualName = "CurrentAverageQuality";
+      islandBestAverageWorstQualityCalculator2.BestQualityParameter.ActualName = "CurrentBestQuality";
+      islandBestAverageWorstQualityCalculator2.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      islandBestAverageWorstQualityCalculator2.QualityParameter.ActualName = QualityParameter.Name;
+      islandBestAverageWorstQualityCalculator2.WorstQualityParameter.ActualName = "CurrentWorstQuality";
+
+      islandDataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best BestQuality", null, "CurrentBestBestQuality"));
+      islandDataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Average BestQuality", null, "CurrentAverageBestQuality"));
+      islandDataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Worst BestQuality", null, "CurrentWorstBestQuality"));
+      islandDataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
+      islandDataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Known Quality", null, BestKnownQualityParameter.Name));
+      islandDataTableValuesCollector3.DataTableParameter.ActualName = "BestQualities";
+
+      islandDataTableValuesCollector4.CollectedValues.Add(new LookupParameter<DoubleValue>("Selection Pressure", null, "SelectionPressure"));
+      islandDataTableValuesCollector4.CollectedValues.Add(new LookupParameter<DoubleValue>("Maximum Selection Pressure", null, MaximumSelectionPressureParameter.Name));
+      islandDataTableValuesCollector4.DataTableParameter.ActualName = "SelectionPressures";
+
+      islandQualityDifferenceCalculator2.AbsoluteDifferenceParameter.ActualName = "AbsoluteDifferenceBestKnownToBest";
+      islandQualityDifferenceCalculator2.FirstQualityParameter.ActualName = BestKnownQualityParameter.Name;
+      islandQualityDifferenceCalculator2.RelativeDifferenceParameter.ActualName = "RelativeDifferenceBestKnownToBest";
+      islandQualityDifferenceCalculator2.SecondQualityParameter.ActualName = "BestQuality";
+
+      islandEvaluatedSolutionsCounter.Name = "Update EvaluatedSolutions";
+      islandEvaluatedSolutionsCounter.ValueParameter.ActualName = "EvaluatedSolutions";
+      islandEvaluatedSolutionsCounter.Increment = null;
+      islandEvaluatedSolutionsCounter.IncrementParameter.ActualName = "IslandEvaluatedSolutions";
+
+      islandSelectionPressureComparator.Name = "SelectionPressure >= MaximumSelectionPressure ?";
+      islandSelectionPressureComparator.LeftSideParameter.ActualName = "SelectionPressure";
+      islandSelectionPressureComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      islandSelectionPressureComparator.RightSideParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      islandSelectionPressureComparator.ResultParameter.ActualName = "TerminateSelectionPressure";
+
+      islandTerminatedBySelectionPressure2.Name = "Island Terminated ?";
+      islandTerminatedBySelectionPressure2.ConditionParameter.ActualName = "TerminateSelectionPressure";
+
+      terminatedIslandsCounter.Name = "TerminatedIslands + 1";
+      terminatedIslandsCounter.ValueParameter.ActualName = "TerminatedIslands";
+      terminatedIslandsCounter.Increment = new IntValue(1);
+
+      generationsCounter.Name = "Generations + 1";
+      generationsCounter.ValueParameter.ActualName = "Generations";
+      generationsCounter.Increment = new IntValue(1);
+
+      generationsSinceLastMigrationCounter.Name = "GenerationsSinceLastMigration + 1";
+      generationsSinceLastMigrationCounter.ValueParameter.ActualName = "GenerationsSinceLastMigration";
+      generationsSinceLastMigrationCounter.Increment = new IntValue(1);
+
+      migrationComparator.Name = "GenerationsSinceLastMigration = MigrationInterval ?";
+      migrationComparator.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
+      migrationComparator.Comparison = new Comparison(ComparisonType.Equal);
+      migrationComparator.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
+      migrationComparator.ResultParameter.ActualName = "Migrate";
+
+      migrationBranch.Name = "Migrate?";
+      migrationBranch.ConditionParameter.ActualName = "Migrate";
+
+      resetTerminatedIslandsAssigner.Name = "Reset TerminatedIslands";
+      resetTerminatedIslandsAssigner.LeftSideParameter.ActualName = "TerminatedIslands";
+      resetTerminatedIslandsAssigner.RightSideParameter.Value = new IntValue(0);
+
+      resetGenerationsSinceLastMigrationAssigner.Name = "Reset GenerationsSinceLastMigration";
+      resetGenerationsSinceLastMigrationAssigner.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
+      resetGenerationsSinceLastMigrationAssigner.RightSideParameter.Value = new IntValue(0);
 
       migrationsCounter.Name = "Migrations + 1";
@@ -278,26 +415,53 @@
       migrationsCounter.ValueParameter.ActualName = "Migrations";
 
-      maxMigrationsComparator.Name = "Migrations >= MaximumMigration ?";
-      maxMigrationsComparator.LeftSideParameter.ActualName = "Migrations";
-      maxMigrationsComparator.RightSideParameter.ActualName = MaximumMigrationsParameter.Name;
-      maxMigrationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
-      maxMigrationsComparator.ResultParameter.ActualName = "MigrationTerminate";
-
+      reviveIslandAssigner.Name = "Revive Island";
+      reviveIslandAssigner.LeftSideParameter.ActualName = "TerminateSelectionPressure";
+      reviveIslandAssigner.RightSideParameter.Value = new BoolValue(false);
+
+      emigrantsSelector.Name = "Emigrants Selector (placeholder)";
+      emigrantsSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
+
+      migrator.Name = "Migrator (placeholder)";
+      migrator.OperatorParameter.ActualName = MigratorParameter.Name;
+
+      immigrationReplacer.Name = "Immigration Replacer (placeholder)";
+      immigrationReplacer.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
+
+      generationsComparator.Name = "Generations >= MaximumGenerations ?";
+      generationsComparator.LeftSideParameter.ActualName = "Generations";
+      generationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      generationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
+      generationsComparator.ResultParameter.ActualName = "TerminateGenerations";
+
+      terminatedIslandsComparator.Name = "All Islands terminated ?";
+      terminatedIslandsComparator.LeftSideParameter.ActualName = "TerminatedIslands";
+      terminatedIslandsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      terminatedIslandsComparator.RightSideParameter.ActualName = NumberOfIslandsParameter.Name;
+      terminatedIslandsComparator.ResultParameter.ActualName = "TerminateTerminatedIslands";
+      
       bestQualityMemorizer3.BestQualityParameter.ActualName = "BestQuality";
       bestQualityMemorizer3.MaximizationParameter.ActualName = MaximizationParameter.Name;
       bestQualityMemorizer3.QualityParameter.ActualName = "BestQuality";
 
-      bestAverageWorstQualityCalculator3.AverageQualityParameter.ActualName = "CurrentAverageBestQuality";
-      bestAverageWorstQualityCalculator3.BestQualityParameter.ActualName = "CurrentBestBestQuality";
-      bestAverageWorstQualityCalculator3.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      bestAverageWorstQualityCalculator3.QualityParameter.ActualName = "CurrentBestQuality";
-      bestAverageWorstQualityCalculator3.WorstQualityParameter.ActualName = "CurrentWorstBestQuality";
-
-      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best BestQuality", null, "CurrentBestBestQuality"));
-      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Average BestQuality", null, "CurrentAverageBestQuality"));
-      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Worst BestQuality", null, "CurrentWorstBestQuality"));
-      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
-      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Known Quality", null, BestKnownQualityParameter.Name));
-      dataTableValuesCollector2.DataTableParameter.ActualName = "BestQualities";
+      bestQualityMemorizer4.BestQualityParameter.ActualName = BestKnownQualityParameter.Name;
+      bestQualityMemorizer4.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      bestQualityMemorizer4.QualityParameter.ActualName = "BestQuality";
+
+      bestAverageWorstQualityCalculator2.AverageQualityParameter.ActualName = "CurrentAverageBestQuality";
+      bestAverageWorstQualityCalculator2.BestQualityParameter.ActualName = "CurrentBestBestQuality";
+      bestAverageWorstQualityCalculator2.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      bestAverageWorstQualityCalculator2.QualityParameter.ActualName = "CurrentBestQuality";
+      bestAverageWorstQualityCalculator2.WorstQualityParameter.ActualName = "CurrentWorstBestQuality";
+
+      dataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best BestQuality", null, "CurrentBestBestQuality"));
+      dataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Average BestQuality", null, "CurrentAverageBestQuality"));
+      dataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Worst BestQuality", null, "CurrentWorstBestQuality"));
+      dataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
+      dataTableValuesCollector3.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Known Quality", null, BestKnownQualityParameter.Name));
+      dataTableValuesCollector3.DataTableParameter.ActualName = "BestQualities";
+
+      dataTableValuesCollector4.CollectedValues.Add(new LookupParameter<DoubleValue>("Maximum Selection Pressure", null, MaximumSelectionPressureParameter.Name));
+      dataTableValuesCollector4.CollectedValues.Add(new SubScopesLookupParameter<DoubleValue>("Selection Pressure Island", null, "SelectionPressure"));
+      dataTableValuesCollector4.DataTableParameter.ActualName = "SelectionPressures";
 
       qualityDifferenceCalculator2.AbsoluteDifferenceParameter.ActualName = "AbsoluteDifferenceBestKnownToBest";
@@ -306,40 +470,80 @@
       qualityDifferenceCalculator2.SecondQualityParameter.ActualName = "BestQuality";
 
-      migrationTerminationCondition.ConditionParameter.ActualName = "MigrationTerminate";
+      generationsTerminationCondition.Name = "Terminate (MaxGenerations) ?";
+      generationsTerminationCondition.ConditionParameter.ActualName = "TerminateGenerations";
+
+      terminatedIslandsCondition.Name = "Terminate (TerminatedIslands) ?";
+      terminatedIslandsCondition.ConditionParameter.ActualName = "TerminateTerminatedIslands";
       #endregion
 
       #region Create operator graph
       OperatorGraph.InitialOperator = variableCreator;
-      variableCreator.Successor = ussp0;
-      ussp0.Operator = islandVariableCreator;
-      ussp0.Successor = bestQualityMemorizer2;
-      islandVariableCreator.Successor = islandVariableAssigner;
-      islandVariableAssigner.Successor = bestQualityMemorizer1;
-      bestQualityMemorizer1.Successor = bestAverageWorstQualityCalculator1;
-      bestQualityMemorizer2.Successor = bestAverageWorstQualityCalculator2;
-      bestAverageWorstQualityCalculator2.Successor = dataTableValuesCollector1;
-      dataTableValuesCollector1.Successor = qualityDifferenceCalculator1;
+      variableCreator.Successor = uniformSubScopesProcessor0;
+      uniformSubScopesProcessor0.Operator = islandVariableCreator;
+      uniformSubScopesProcessor0.Successor = bestQualityMemorizer1;
+      islandVariableCreator.Successor = islandBestQualityMemorizer1;
+      islandBestQualityMemorizer1.Successor = islandBestAverageWorstQualityCalculator1;
+      islandBestAverageWorstQualityCalculator1.Successor = islandDataTableValuesCollector1;
+      islandDataTableValuesCollector1.Successor = islandDataTableValuesCollector2;
+      islandDataTableValuesCollector2.Successor = islandQualityDifferenceCalculator1;
+      islandQualityDifferenceCalculator1.Successor = islandVisualizer1;
+      islandVisualizer1.Successor = islandResultsCollector;
+      islandResultsCollector.Successor = null;
+      bestQualityMemorizer1.Successor = bestQualityMemorizer2;
+      bestQualityMemorizer2.Successor = bestAverageWorstQualityCalculator1;
+      bestAverageWorstQualityCalculator1.Successor = dataTableValuesCollector1;
+      dataTableValuesCollector1.Successor = dataTableValuesCollector2;
+      dataTableValuesCollector2.Successor = qualityDifferenceCalculator1;
       qualityDifferenceCalculator1.Successor = resultsCollector;
-      resultsCollector.Successor = ussp1;
-      ussp1.Operator = mainLoop;
-      ussp1.Successor = migrator;
-      mainLoop.Successor = maximumGenerationsCounter;
-      maximumGenerationsCounter.Successor = emigrantsSelector;
+      resultsCollector.Successor = comparisonFactorModifier;
+      comparisonFactorModifier.Successor = uniformSubScopesProcessor1;
+      uniformSubScopesProcessor1.Operator = islandTerminatedBySelectionPressure1;
+      uniformSubScopesProcessor1.Successor = generationsCounter;
+      islandTerminatedBySelectionPressure1.TrueBranch = null;
+      islandTerminatedBySelectionPressure1.FalseBranch = mainOperator;
+      islandTerminatedBySelectionPressure1.Successor = null;
+      mainOperator.Successor = islandBestQualityMemorizer2;
+      islandBestQualityMemorizer2.Successor = islandBestAverageWorstQualityCalculator2;
+      islandBestAverageWorstQualityCalculator2.Successor = islandDataTableValuesCollector3;
+      islandDataTableValuesCollector3.Successor = islandDataTableValuesCollector4;
+      islandDataTableValuesCollector4.Successor = islandQualityDifferenceCalculator2;
+      islandQualityDifferenceCalculator2.Successor = islandVisualizer2;
+      islandVisualizer2.Successor = islandEvaluatedSolutionsCounter;
+      islandEvaluatedSolutionsCounter.Successor = islandSelectionPressureComparator;
+      islandSelectionPressureComparator.Successor = islandTerminatedBySelectionPressure2;
+      islandTerminatedBySelectionPressure2.TrueBranch = terminatedIslandsCounter;
+      islandTerminatedBySelectionPressure2.FalseBranch = null;
+      islandTerminatedBySelectionPressure2.Successor = null;
+      generationsCounter.Successor = generationsSinceLastMigrationCounter;
+      generationsSinceLastMigrationCounter.Successor = migrationComparator;
+      migrationComparator.Successor = migrationBranch;
+      migrationBranch.TrueBranch = resetTerminatedIslandsAssigner;
+      migrationBranch.FalseBranch = null;
+      migrationBranch.Successor = generationsComparator;
+      resetTerminatedIslandsAssigner.Successor = resetGenerationsSinceLastMigrationAssigner;
+      resetGenerationsSinceLastMigrationAssigner.Successor = migrationsCounter;
+      migrationsCounter.Successor = uniformSubScopesProcessor2;
+      uniformSubScopesProcessor2.Operator = reviveIslandAssigner;
+      uniformSubScopesProcessor2.Successor = migrator;
+      reviveIslandAssigner.Successor = emigrantsSelector;
       emigrantsSelector.Successor = null;
-      migrator.Successor = ussp2;
-      ussp2.Operator = mergingReducer;
-      ussp2.Successor = migrationsCounter;
-      mergingReducer.Successor = immigrationSelector;
-      immigrationSelector.Successor = rightReducer;
-      rightReducer.Successor = null;
-      migrationsCounter.Successor = maxMigrationsComparator;
-      maxMigrationsComparator.Successor = bestQualityMemorizer3;
-      bestQualityMemorizer3.Successor = bestAverageWorstQualityCalculator3;
-      bestAverageWorstQualityCalculator3.Successor = dataTableValuesCollector2;
-      dataTableValuesCollector2.Successor = qualityDifferenceCalculator2;
-      qualityDifferenceCalculator2.Successor = migrationTerminationCondition;
-      migrationTerminationCondition.FalseBranch = ussp1;
-      migrationTerminationCondition.TrueBranch = null;
-      migrationTerminationCondition.Successor = null;
+      migrator.Successor = uniformSubScopesProcessor3;
+      uniformSubScopesProcessor3.Operator = immigrationReplacer;
+      uniformSubScopesProcessor3.Successor = null;
+      immigrationReplacer.Successor = null;
+      generationsComparator.Successor = terminatedIslandsComparator;
+      terminatedIslandsComparator.Successor = bestQualityMemorizer3;
+      bestQualityMemorizer3.Successor = bestQualityMemorizer4;
+      bestQualityMemorizer4.Successor = bestAverageWorstQualityCalculator2;
+      bestAverageWorstQualityCalculator2.Successor = dataTableValuesCollector3;
+      dataTableValuesCollector3.Successor = dataTableValuesCollector4;
+      dataTableValuesCollector4.Successor = qualityDifferenceCalculator2;
+      qualityDifferenceCalculator2.Successor = generationsTerminationCondition;
+      generationsTerminationCondition.TrueBranch = null;
+      generationsTerminationCondition.FalseBranch = terminatedIslandsCondition;
+      generationsTerminationCondition.Successor = null;
+      terminatedIslandsCondition.TrueBranch = null;
+      terminatedIslandsCondition.FalseBranch = comparisonFactorModifier;
+      terminatedIslandsCondition.Successor = null;
       #endregion
     }
Index: trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithmMainOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithmMainOperator.cs	(revision 3611)
+++ trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithmMainOperator.cs	(revision 3611)
@@ -0,0 +1,257 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Analysis;
+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.OffspringSelectionGeneticAlgorithm {
+  /// <summary>
+  /// An operator which represents the main loop of an offspring selection genetic algorithm.
+  /// </summary>
+  [Item("OffspringSelectionGeneticAlgorithmMainOperator", "An operator that represents the core of an offspring selection genetic algorithm.")]
+  [StorableClass]
+  public sealed class OffspringSelectionGeneticAlgorithmMainOperator : AlgorithmOperator {
+    #region Parameter properties
+    public ValueLookupParameter<IRandom> RandomParameter {
+      get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public SubScopesLookupParameter<DoubleValue> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    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 LookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (LookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+    public ValueLookupParameter<IntValue> ElitesParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
+    }
+    public LookupParameter<DoubleValue> ComparisonFactorParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["ComparisonFactor"]; }
+    }
+    public LookupParameter<DoubleValue> CurrentSuccessRatioParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["CurrentSuccessRatio"]; }
+    }
+    public ValueLookupParameter<DoubleValue> SuccessRatioParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
+    }
+    public LookupParameter<DoubleValue> SelectionPressureParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["SelectionPressure"]; }
+    }
+    public ValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
+    }
+    public ValueLookupParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private OffspringSelectionGeneticAlgorithmMainOperator(bool deserializing) : base() { }
+    public OffspringSelectionGeneticAlgorithmMainOperator()
+      : base() {
+      Initialize();
+    }
+
+    private void Initialize() {
+      #region Create parameters
+      Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      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 LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
+      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 LookupParameter<DoubleValue>("CurrentSuccessRatio", "The current success ratio."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
+      Parameters.Add(new LookupParameter<DoubleValue>("SelectionPressure", "The actual selection pressure."));
+      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."));
+      #endregion
+
+      #region Create operators
+      Placeholder selector = new Placeholder();
+      SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
+      ChildrenCreator childrenCreator = new ChildrenCreator();
+      UniformSubScopesProcessor uniformSubScopesProcessor = new UniformSubScopesProcessor();
+      Placeholder crossover = new Placeholder();
+      ConditionalBranch osBeforeMutationBranch = new ConditionalBranch();
+      Placeholder evaluator1 = new Placeholder();
+      IntCounter evaluationCounter1 = new IntCounter();
+      WeightedParentsQualityComparator qualityComparer1 = new WeightedParentsQualityComparator();
+      StochasticBranch mutationBranch1 = new StochasticBranch();
+      Placeholder mutator1 = new Placeholder();
+      Placeholder evaluator2 = new Placeholder();
+      IntCounter evaluationCounter2 = new IntCounter();
+      StochasticBranch mutationBranch2 = new StochasticBranch();
+      Placeholder mutator2 = new Placeholder();
+      Placeholder evaluator3 = new Placeholder();
+      IntCounter evaluationCounter3 = new IntCounter();
+      WeightedParentsQualityComparator qualityComparer2 = new WeightedParentsQualityComparator();
+      SubScopesRemover subScopesRemover = new SubScopesRemover();
+      ConditionalSelector conditionalSelector = new ConditionalSelector();
+      OffspringSelector offspringSelector = new OffspringSelector();
+      SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
+      BestSelector bestSelector = new BestSelector();
+      RightReducer rightReducer = new RightReducer();
+      MergingReducer mergingReducer = new MergingReducer();
+      
+      selector.Name = "Selector (placeholder)";
+      selector.OperatorParameter.ActualName = SelectorParameter.Name;
+
+      childrenCreator.ParentsPerChild = new IntValue(2);
+
+      crossover.Name = "Crossover (placeholder)";
+      crossover.OperatorParameter.ActualName = CrossoverParameter.Name;
+
+      osBeforeMutationBranch.Name = "Apply OS before mutation?";
+      osBeforeMutationBranch.ConditionParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
+
+      evaluator1.Name = "Evaluator (placeholder)";
+      evaluator1.OperatorParameter.ActualName = EvaluatorParameter.Name;
+
+      evaluationCounter1.Name = "EvaluatedSolutions++";
+      evaluationCounter1.Increment = new IntValue(1);
+      evaluationCounter1.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+
+      qualityComparer1.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      qualityComparer1.LeftSideParameter.ActualName = QualityParameter.Name;
+      qualityComparer1.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      qualityComparer1.RightSideParameter.ActualName = QualityParameter.Name;
+      qualityComparer1.ResultParameter.ActualName = "SuccessfulOffspring";
+
+      mutationBranch1.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      mutationBranch1.RandomParameter.ActualName = RandomParameter.Name;
+
+      mutator1.Name = "Mutator (placeholder)";
+      mutator1.OperatorParameter.ActualName = MutatorParameter.Name;
+
+      evaluator2.Name = "Evaluator (placeholder)";
+      evaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;
+
+      evaluationCounter2.Name = "EvaluatedSolutions++";
+      evaluationCounter2.Increment = new IntValue(1);
+      evaluationCounter2.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+
+      mutationBranch2.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      mutationBranch2.RandomParameter.ActualName = RandomParameter.Name;
+
+      mutator2.Name = "Mutator (placeholder)";
+      mutator2.OperatorParameter.ActualName = MutatorParameter.Name;
+
+      evaluator3.Name = "Evaluator (placeholder)";
+      evaluator3.OperatorParameter.ActualName = EvaluatorParameter.Name;
+
+      evaluationCounter3.Name = "EvaluatedSolutions++";
+      evaluationCounter3.Increment = new IntValue(1);
+      evaluationCounter3.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+
+      qualityComparer2.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      qualityComparer2.LeftSideParameter.ActualName = QualityParameter.Name;
+      qualityComparer2.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      qualityComparer2.RightSideParameter.ActualName = QualityParameter.Name;
+      qualityComparer2.ResultParameter.ActualName = "SuccessfulOffspring";
+
+      subScopesRemover.RemoveAllSubScopes = true;
+
+      conditionalSelector.CopySelected = new BoolValue(false);
+      conditionalSelector.ConditionParameter.ActualName = "SuccessfulOffspring";
+
+      offspringSelector.CurrentSuccessRatioParameter.ActualName = CurrentSuccessRatioParameter.Name;
+      offspringSelector.LuckyLosersParameter.ActualName = "OSLuckyLosers";
+      offspringSelector.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      offspringSelector.SelectionPressureParameter.ActualName = SelectionPressureParameter.Name;
+      offspringSelector.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+      offspringSelector.WinnersParameter.ActualName = "OSWinners";
+
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = ElitesParameter.Name;
+      bestSelector.QualityParameter.ActualName = QualityParameter.Name;
+      #endregion
+
+      #region Create operator graph
+      OperatorGraph.InitialOperator = selector;
+      selector.Successor = subScopesProcessor1;
+      subScopesProcessor1.Operators.Add(new EmptyOperator());
+      subScopesProcessor1.Operators.Add(childrenCreator);
+      subScopesProcessor1.Successor = offspringSelector;
+      childrenCreator.Successor = uniformSubScopesProcessor;
+      uniformSubScopesProcessor.Operator = crossover;
+      uniformSubScopesProcessor.Successor = conditionalSelector;
+      crossover.Successor = osBeforeMutationBranch;
+      osBeforeMutationBranch.TrueBranch = evaluator1;
+      osBeforeMutationBranch.FalseBranch = mutationBranch2;
+      osBeforeMutationBranch.Successor = subScopesRemover;
+      evaluator1.Successor = evaluationCounter1;
+      evaluationCounter1.Successor = qualityComparer1;
+      qualityComparer1.Successor = mutationBranch1;
+      mutationBranch1.FirstBranch = mutator1;
+      mutationBranch1.SecondBranch = null;
+      mutationBranch1.Successor = null;
+      mutator1.Successor = evaluator2;
+      evaluator2.Successor = evaluationCounter2;
+      evaluationCounter2.Successor = null;
+      mutationBranch2.FirstBranch = mutator2;
+      mutationBranch2.SecondBranch = null;
+      mutationBranch2.Successor = evaluator3;
+      mutator2.Successor = null;
+      evaluator3.Successor = evaluationCounter3;
+      evaluationCounter3.Successor = qualityComparer2;
+      subScopesRemover.Successor = null;
+      offspringSelector.OffspringCreator = selector;
+      offspringSelector.Successor = subScopesProcessor2;
+      subScopesProcessor2.Operators.Add(bestSelector);
+      subScopesProcessor2.Operators.Add(new EmptyOperator());
+      subScopesProcessor2.Successor = mergingReducer;
+      bestSelector.Successor = rightReducer;
+      rightReducer.Successor = null;
+      mergingReducer.Successor = null;
+      #endregion
+    }
+  }
+}
