Index: unk/sources/HeuristicLab.FixedOperators/3.2/FixedBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.FixedOperators/3.2/FixedBase.cs	(revision 1788)
+++ 	(revision )
@@ -1,63 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Operators;
-
-namespace HeuristicLab.FixedOperators {
-  class FixedBase : CombinedOperator {
-
-    protected virtual void Execute(IOperator op, IScope scope){
-      IOperation operation;
-      IOperator currentOperator;
-      Stack<IOperation> executionStack = new Stack<IOperation>();
-      executionStack.Push(op.Execute(scope));
-
-      while (executionStack.Count > 0) {
-        operation = executionStack.Pop();
-        if (operation is AtomicOperation) {
-          AtomicOperation atomicOperation = (AtomicOperation)operation;
-          IOperation next = null;
-          try {
-            currentOperator = atomicOperation.Operator;
-            next = atomicOperation.Operator.Execute(atomicOperation.Scope);
-          }
-          catch (Exception) {
-            //Abort();
-            //ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(ex); });
-            throw new InvalidOperationException("Invalid Operation occured in FixedBase.Execute");
-          }
-          if (next != null)
-            executionStack.Push(next);
-        } else if (operation is CompositeOperation) {
-          CompositeOperation compositeOperation = (CompositeOperation)operation;
-          for (int i = compositeOperation.Operations.Count - 1; i >= 0; i--)
-            executionStack.Push(compositeOperation.Operations[i]);
-        } // else if
-      } // while
-    } // Execute
-
-  } // class FixedBase
-} // namespace HeuristicLab.FixedOperators
Index: /trunk/sources/HeuristicLab.FixedOperators/3.2/FixedOperatorBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.FixedOperators/3.2/FixedOperatorBase.cs	(revision 1789)
+++ /trunk/sources/HeuristicLab.FixedOperators/3.2/FixedOperatorBase.cs	(revision 1789)
@@ -0,0 +1,166 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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;
+using System.Collections.Generic;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Data;
+using System.Threading;
+using System.Diagnostics;
+
+namespace HeuristicLab.FixedOperators {
+  class FixedOperatorBase : CombinedOperator {
+
+    private class TasksList {
+      public IOperator op;
+      public IScope scope;
+      public ManualResetEvent resetEvent;
+    }
+    /// <summary>
+    /// Execution pointer shows which command actually is executed
+    /// </summary>
+    protected int executionPointer;
+
+    /// <summary>
+    /// Execution pointer if execution was aborted previously
+    /// </summary>
+    protected IntData persistedExecutionPointer;
+
+    /// <summary>
+    /// If true, mini engine is executed in its own thread.
+    /// </summary>
+    protected bool threaded;
+
+    protected Thread engineThread;
+
+    /// <summary>
+    /// Current operator in execution.
+    /// </summary>
+    protected IOperator currentOperator;
+
+    public FixedOperatorBase() : base() {
+      //AddVariableInfo(new VariableInfo("ExecutionPointer", "Execution pointer for algorithm abortion", typeof(IntData), VariableKind.New));   
+    } // FixedOperatorBase
+
+    private bool IsExecuted() {
+      return persistedExecutionPointer.Data > executionPointer;
+    } // AlreadyExecuted
+
+    protected virtual void Execute(IOperator op, IScope scope, bool runInThread) {
+      if (!IsExecuted()) {
+        if (runInThread) {
+          try {
+            // causes fatal computing overhead 5:30 minutes for sga
+            //engineThread = new Thread(new ThreadStart(ExecuteOperation));
+            //engineThread.Start();
+            //engineThread.Join();
+
+            // causes computing overhead, 11 sec for sga
+            Stopwatch sw = new Stopwatch();
+            sw.Start();
+            TasksList tl = new TasksList() { op = op, scope = scope, resetEvent = new ManualResetEvent(false) };
+            Console.WriteLine(sw.ElapsedTicks);     
+            ThreadPool.QueueUserWorkItem(new WaitCallback(ExecuteOperationThreaded), (object)tl);
+            Console.WriteLine(sw.ElapsedTicks);
+            WaitHandle.WaitAll(new WaitHandle[] { tl.resetEvent });
+            Console.WriteLine(sw.ElapsedTicks); 
+          }
+          catch (ThreadAbortException) {
+            return;
+          }
+        } else {
+          ExecuteOperation(op, scope);
+        }
+        persistedExecutionPointer.Data++;
+      } // if not executed
+      executionPointer++;
+      Console.WriteLine(executionPointer);
+
+      if (Canceled)
+        throw new CancelException();
+    } // Execute
+
+    private void ExecuteOperationThreaded(object o) {
+      TasksList tl = (TasksList)o;
+      ExecuteOperation(tl.op, tl.scope);
+      tl.resetEvent.Set();
+    } // ExecuteOperationThreaded 
+
+    protected void ExecuteOperation(IOperator op, IScope scope) {
+      IOperation operation;
+      currentOperator = op;
+      operation = op.Execute(scope);
+      if (operation != null) {
+        //IOperator currentOperator;
+        Stack<IOperation> executionStack = new Stack<IOperation>();
+        executionStack.Push(op.Execute(scope));
+
+        while (executionStack.Count > 0) {
+          operation = executionStack.Pop();
+          if (operation is AtomicOperation) {
+            AtomicOperation atomicOperation = (AtomicOperation)operation;
+            IOperation next = null;
+            try {
+              currentOperator = atomicOperation.Operator;
+              next = currentOperator.Execute(atomicOperation.Scope);
+            }
+            catch (Exception) {
+              throw new InvalidOperationException("Invalid Operation occured in FixedBase.Execute");
+            }
+            if (next != null)
+              executionStack.Push(next);
+          } else if (operation is CompositeOperation) {
+            CompositeOperation compositeOperation = (CompositeOperation)operation;
+            for (int i = compositeOperation.Operations.Count - 1; i >= 0; i--)
+              executionStack.Push(compositeOperation.Operations[i]);
+          } // else if
+        } // while
+      } // if (operation != null)
+    } // ExecuteOperation
+
+    public override IOperation Apply(IScope scope) {
+      try {
+        persistedExecutionPointer = scope.GetVariableValue<IntData>("ExecutionPointer", false);
+      }
+      catch (Exception) {
+        persistedExecutionPointer = new IntData(0);
+        scope.AddVariable(new Variable("ExecutionPointer", persistedExecutionPointer));
+      }
+      
+      executionPointer = 0;
+      return null;
+    } // Apply
+
+    public override void Abort() {
+      base.Abort();
+      currentOperator.Abort();
+      //engineThread.Abort();
+    }
+
+
+
+  } // class FixedBase
+
+  class CancelException : Exception { 
+  
+  } // class CancelException
+} // namespace HeuristicLab.FixedOperators
Index: /trunk/sources/HeuristicLab.FixedOperators/3.2/FixedSGAMain.cs
===================================================================
--- /trunk/sources/HeuristicLab.FixedOperators/3.2/FixedSGAMain.cs	(revision 1788)
+++ /trunk/sources/HeuristicLab.FixedOperators/3.2/FixedSGAMain.cs	(revision 1789)
@@ -33,7 +33,8 @@
 using System.Diagnostics;
 using HeuristicLab.Selection;
+using System.Threading;
 
 namespace HeuristicLab.FixedOperators {
-  class FixedSGAMain : FixedBase {
+  class FixedSGAMain : FixedOperatorBase {
     public override string Description {
       get { return @"Implements the functionality of SGAMain with fixed control structures. Operators like selection, crossover, mutation and evaluation are delegated."; }
@@ -60,7 +61,9 @@
     MergingReducer mr;
 
+    Thread executionThread;
+    Thread cancelThread;
+
 
     //long[] timesExecuteCreateChildren;
-
     public FixedSGAMain()
       : base() {
@@ -68,5 +71,4 @@
       AddVariableInfo(new VariableInfo("MaximumGenerations", "Maximum number of generations to create", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("Generations", "Number of processed generations", typeof(IntData), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("ExecutionPointer", "Execution pointer for algorithm abortion", typeof(IntData), VariableKind.New));
 
       Name = "FixedSGAMain";
@@ -111,133 +113,196 @@
 
     public override IOperation Apply(IScope scope) {
-      Stopwatch swApply = new Stopwatch();
-      swApply.Start();
-      for (int i = 0; i < SubOperators.Count; i++) {
-        if (scope.GetVariable(SubOperators[i].Name) != null)
-          scope.RemoveVariable(SubOperators[i].Name);
-        scope.AddVariable(new Variable(SubOperators[i].Name, SubOperators[i]));
+      base.Apply(scope);
+      object o = (object)scope;
+      WorkerMethod(o);
+      //try {
+      //  executionThread = new Thread(new ParameterizedThreadStart(WorkerMethod));
+      //  executionThread.Name = "ExecutionThread";
+      //  executionThread.Start(o);
+
+      //  //cancelThread = new Thread(new ThreadStart(CheckCancelFlag));
+      //  //cancelThread.Name = "CancelFlagCheckerThread";
+      //  //cancelThread.Start();
+
+      //  executionThread.Join();
+      //}
+      //catch (ThreadAbortException) {
+      //  return new AtomicOperation(this, scope);
+      //}
+
+      if (Canceled) {
+        return new AtomicOperation(this, scope);
       }
 
-      OperatorBase selector = (OperatorBase)GetVariableValue("Selector", scope, true);
-      QualityLogger ql = new QualityLogger();
-
-      BestAverageWorstQualityCalculator bawqc = new BestAverageWorstQualityCalculator();
-      DataCollector dc = new DataCollector();
-      ItemList<StringData> names = dc.GetVariable("VariableNames").GetValue<ItemList<StringData>>();
-      names.Add(new StringData("BestQuality"));
-      names.Add(new StringData("AverageQuality"));
-      names.Add(new StringData("WorstQuality"));
-
-      LinechartInjector lci = new LinechartInjector();
-      lci.GetVariableInfo("Linechart").ActualName = "Quality Linechart";
-      lci.GetVariable("NumberOfLines").GetValue<IntData>().Data = 3;
-
-      LessThanComparator ltc = new LessThanComparator();
-      ltc.GetVariableInfo("LeftSide").ActualName = "Generations";
-      ltc.GetVariableInfo("RightSide").ActualName = "MaximumGenerations";
-      ltc.GetVariableInfo("Result").ActualName = "GenerationsCondition";
-
-      IntData maxGenerations = GetVariableValue<IntData>("MaximumGenerations", scope, true);
-      IntData nrOfGenerations = GetVariableValue<IntData>("Generations", scope, true);
-
-
-      // executionpointer saves the reentry point after engine abort occurs.
-      IntData executionPointer;
+      return null;
+    } // Apply
+
+    private void CheckCancelFlag() {
+      while (executionThread.IsAlive) {
+        if (Canceled) {
+          executionThread.Abort();
+          return;
+        }
+        Thread.Sleep(500);
+      } // while
+    } // CheckCancelFlag
+
+    private void WorkerMethod(object o) {
       try {
-        executionPointer = GetVariableValue<IntData>("ExecutionPointer", scope, true);
+        IScope scope = o as IScope;
+        Stopwatch swApply = new Stopwatch();
+        swApply.Start();
+        for (int i = 0; i < SubOperators.Count; i++) {
+          if (scope.GetVariable(SubOperators[i].Name) != null)
+            scope.RemoveVariable(SubOperators[i].Name);
+          scope.AddVariable(new Variable(SubOperators[i].Name, SubOperators[i]));
+        }
+
+        OperatorBase selector = (OperatorBase)GetVariableValue("Selector", scope, true);
+        QualityLogger ql = new QualityLogger();
+
+        BestAverageWorstQualityCalculator bawqc = new BestAverageWorstQualityCalculator();
+        DataCollector dc = new DataCollector();
+        ItemList<StringData> names = dc.GetVariable("VariableNames").GetValue<ItemList<StringData>>();
+        names.Add(new StringData("BestQuality"));
+        names.Add(new StringData("AverageQuality"));
+        names.Add(new StringData("WorstQuality"));
+
+        LinechartInjector lci = new LinechartInjector();
+        lci.GetVariableInfo("Linechart").ActualName = "Quality Linechart";
+        lci.GetVariable("NumberOfLines").GetValue<IntData>().Data = 3;
+
+        LessThanComparator ltc = new LessThanComparator();
+        ltc.GetVariableInfo("LeftSide").ActualName = "Generations";
+        ltc.GetVariableInfo("RightSide").ActualName = "MaximumGenerations";
+        ltc.GetVariableInfo("Result").ActualName = "GenerationsCondition";
+
+        IntData maxGenerations = GetVariableValue<IntData>("MaximumGenerations", scope, true);
+        IntData nrOfGenerations = GetVariableValue<IntData>("Generations", scope, true);
+        nrOfGenerations.Data = 0;
+
+        threaded = false;
+        // fetch variables from scope for create children
+        InitializeExecuteCreateChildren(scope);
+        try {
+          //for (int i = nrOfGenerations.Data; i < maxGenerations.Data; i++) {
+          //  Execute(selector, scope, false);
+          //  ExecuteCreateChildrenWithFixedControlStructures(scope.SubScopes[1]);
+          //  ExecuteCreateReplacementWithFixedConstrolStructures(scope);
+          //  ql.Execute(scope);
+          //  bawqc.Execute(scope);
+          //  dc.Execute(scope);
+          //  lci.Execute(scope);
+          //  nrOfGenerations.Data++;
+          //} // for i
+          for (int i = 0; i < maxGenerations.Data; i++) {
+            Execute(selector, scope, false);
+            ExecuteCreateChildrenWithFixedControlStructures(scope.SubScopes[1]);
+            ExecuteCreateReplacementWithFixedConstrolStructures(scope);
+            Execute(ql, scope, false);
+            Execute(bawqc, scope, false);
+            Execute(dc, scope, false);
+            Execute(lci, scope, false);
+            nrOfGenerations.Data++;
+          } // for i
+        } // try
+        catch (CancelException) {
+          Console.WriteLine("Micro engine aborted by cancel flag.");
+        }
+
+        //for (int i = nrOfGenerations.Data; i < maxGenerations.Data && !Canceled; i++) {
+        //  if (Canceled) {
+        //    executionPointer.Data = -1;
+        //    continue;
+        //  }
+        //  if (executionPointer.Data < 0)
+        //    Execute(selector, scope);
+
+        //  if (Canceled) {
+        //    executionPointer.Data = 0;
+        //    continue;
+        //  }
+        //  if (executionPointer.Data < 1)
+        //    ExecuteCreateChildrenWithFixedControlStructures(scope.SubScopes[1]);
+
+        //  if (Canceled) {
+        //    executionPointer.Data = 1;
+        //    continue;
+        //  }
+        //  if (executionPointer.Data < 2)
+        //    ExecuteCreateReplacementWithFixedConstrolStructures(scope);
+
+        //  if (Canceled) {
+        //    executionPointer.Data = 2;
+        //    continue;
+        //  }
+        //  if (executionPointer.Data < 3) {
+        //    ql.Execute(scope);
+        //    bawqc.Execute(scope);
+        //    dc.Execute(scope);
+        //    lci.Execute(scope);
+        //    nrOfGenerations.Data++;
+        //  }
+        //  executionPointer.Data = -1;
+        //} // for i
+
+
+        //Stopwatch watch = new Stopwatch();
+        //long[] times = new long[10];
+        //timesExecuteCreateChildren = new long[10];
+        //for (int i = nrOfGenerations.Data; i < maxGenerations.Data && !Canceled; i++) {
+        //  watch.Start();
+        //  selector.Execute(scope);
+        //  watch.Stop();
+        //  times[0] += watch.ElapsedTicks;
+        //  watch.Reset();
+        //  watch.Start();
+        //  ExecuteCreateChildrenWithFixedControlStructures(scope.SubScopes[1]);
+        //  watch.Stop();
+        //  times[1] += watch.ElapsedTicks;
+        //  watch.Reset();
+        //  watch.Start();
+        //  ExecuteCreateReplacementWithFixedConstrolStructures(scope);
+        //  watch.Stop();
+        //  times[2] += watch.ElapsedTicks;
+        //  watch.Reset();
+        //  watch.Start();
+        //  ql.Execute(scope);
+        //  watch.Stop();
+        //  times[3] += watch.ElapsedTicks;
+        //  watch.Reset();
+        //  watch.Start();
+        //  bawqc.Execute(scope);
+        //  watch.Stop();
+        //  times[4] += watch.ElapsedTicks;
+        //  watch.Reset();
+        //  watch.Start();
+        //  dc.Execute(scope);
+        //  watch.Stop();
+        //  times[5] += watch.ElapsedTicks;
+        //  watch.Reset();
+        //  watch.Start();
+        //  lci.Execute(scope);
+        //  watch.Stop();
+        //  times[6] += watch.ElapsedTicks;
+        //  watch.Reset();
+        //  watch.Start();
+        //  nrOfGenerations.Data++;
+        //}
+
+        swApply.Stop();
+        Console.WriteLine("SGAMain.Apply(): {0}", swApply.Elapsed);
+
+        //if (Canceled) {
+        //  return new AtomicOperation(this, scope);
+        //}
+
+        //return null;
+
       }
-      catch (Exception) {
-        scope.AddVariable(new Variable("ExecutionPointer", new IntData(-1)));
-        executionPointer = GetVariableValue<IntData>("ExecutionPointer", scope, true);
+      catch (ThreadAbortException) {
+
+        throw;
       }
-
-      // fetch variables from scope for create children
-      InitializeExecuteCreateChildren(scope);
-      for (int i = nrOfGenerations.Data; i < maxGenerations.Data && !Canceled; i++) {
-        if (Canceled) {
-          executionPointer.Data = -1;
-          continue;
-        }
-        if (executionPointer.Data < 0)
-          Execute(selector, scope);
-
-        if (Canceled) {
-          executionPointer.Data = 0;
-          continue;
-        }
-        if (executionPointer.Data < 1)
-          ExecuteCreateChildrenWithFixedControlStructures(scope.SubScopes[1]);
-
-        if (Canceled) {
-          executionPointer.Data = 1;
-          continue;
-        }
-        if (executionPointer.Data < 2)
-          ExecuteCreateReplacementWithFixedConstrolStructures(scope);
-
-        if (Canceled) {
-          executionPointer.Data = 2;
-          continue;
-        }
-        if (executionPointer.Data < 3) {
-          ql.Execute(scope);
-          bawqc.Execute(scope);
-          dc.Execute(scope);
-          lci.Execute(scope);
-          nrOfGenerations.Data++;
-        }
-        executionPointer.Data = -1;
-      } // for i
-
-      //Stopwatch watch = new Stopwatch();
-      //long[] times = new long[10];
-      //timesExecuteCreateChildren = new long[10];
-      //for (int i = nrOfGenerations.Data; i < maxGenerations.Data && !Canceled; i++) {
-      //  watch.Start();
-      //  selector.Execute(scope);
-      //  watch.Stop();
-      //  times[0] += watch.ElapsedTicks;
-      //  watch.Reset();
-      //  watch.Start();
-      //  ExecuteCreateChildrenWithFixedControlStructures(scope.SubScopes[1]);
-      //  watch.Stop();
-      //  times[1] += watch.ElapsedTicks;
-      //  watch.Reset();
-      //  watch.Start();
-      //  ExecuteCreateReplacementWithFixedConstrolStructures(scope);
-      //  watch.Stop();
-      //  times[2] += watch.ElapsedTicks;
-      //  watch.Reset();
-      //  watch.Start();
-      //  ql.Execute(scope);
-      //  watch.Stop();
-      //  times[3] += watch.ElapsedTicks;
-      //  watch.Reset();
-      //  watch.Start();
-      //  bawqc.Execute(scope);
-      //  watch.Stop();
-      //  times[4] += watch.ElapsedTicks;
-      //  watch.Reset();
-      //  watch.Start();
-      //  dc.Execute(scope);
-      //  watch.Stop();
-      //  times[5] += watch.ElapsedTicks;
-      //  watch.Reset();
-      //  watch.Start();
-      //  lci.Execute(scope);
-      //  watch.Stop();
-      //  times[6] += watch.ElapsedTicks;
-      //  watch.Reset();
-      //  watch.Start();
-      //  nrOfGenerations.Data++;
-      //}
-
-      swApply.Stop();
-      Console.WriteLine("SGAMain.Apply(): {0}", swApply.Elapsed);
-
-      if (Canceled)
-        return new AtomicOperation(this, scope);
-
-      return null;
     } // Apply
 
@@ -264,31 +329,66 @@
     /// <param name="scope"></param>
     protected void ExecuteCreateChildrenWithFixedControlStructures(IScope scope) {
+      //// ChildrenInitializer
+      //ci.Apply(scope);
+      //// UniformSequentialSubScopesProcessor
+      //foreach (IScope s in scope.SubScopes) {
+      //  Execute(crossover, s, false);
+      //  // Stochastic Branch
+      //  if (random.NextDouble() < probability.Data)
+      //    Execute(mutator, s, false);
+      //  Execute(evaluator, s, false);
+      //  sr.Execute(s);
+      //  counter.Execute(s);
+      //} // foreach
+
+      //sorter.Execute(scope);
+
+      EmptyOperator empty = new EmptyOperator();
+
       // ChildrenInitializer
-      ci.Apply(scope);
+      Execute(ci, scope, false);
       // UniformSequentialSubScopesProcessor
       foreach (IScope s in scope.SubScopes) {
-        Execute(crossover, s);
+        Execute(crossover, s, false);
         // Stochastic Branch
         if (random.NextDouble() < probability.Data)
-          Execute(mutator, s);
-        Execute(evaluator, s);
-        sr.Execute(s);
-        counter.Execute(s);
+          Execute(mutator, s, false);
+        else
+          Execute(empty, s, false);
+        Execute(evaluator, s, false);
+        Execute(sr, s, false);
+        Execute(counter, s, false);
       } // foreach
 
-      sorter.Execute(scope);
+      Execute(sorter, scope, false);
     } // ExecuteCreateChildrenHWCS
 
     private void ExecuteCreateReplacementWithFixedConstrolStructures(IScope scope) {
-      // SequentialSubScopesProcessor
-      ls.Execute(scope.SubScopes[0]);
-      rr.Execute(scope.SubScopes[0]);
-
-      rs.Execute(scope.SubScopes[1]);
-      lr.Execute(scope.SubScopes[1]);
-
-      mr.Execute(scope);
-      sorter.Execute(scope);
+      //// SequentialSubScopesProcessor
+      //ls.Execute(scope.SubScopes[0]);
+      //rr.Execute(scope.SubScopes[0]);
+
+      //rs.Execute(scope.SubScopes[1]);
+      //lr.Execute(scope.SubScopes[1]);
+
+      //mr.Execute(scope);
+      //sorter.Execute(scope);
+
+      Execute(ls, scope.SubScopes[0], false);
+      Execute(rr, scope.SubScopes[0], false);
+
+      Execute(rs, scope.SubScopes[1], false);
+      Execute(lr, scope.SubScopes[1], false);
+
+      Execute(mr, scope, false);
+      Execute(sorter, scope, false);
+
     } // ExecuteCreateReplacementWithFixedConstrolStructures
+
+    //public override void Abort() {
+    //  base.Abort();
+    //  executionThread.Abort();
+    //} // Abort
+
   } // class FixedSGAMain
 } // namespace HeuristicLab.FixedOperators
Index: /trunk/sources/HeuristicLab.FixedOperators/3.2/HeuristicLab.FixedOperators-3.2.csproj
===================================================================
--- /trunk/sources/HeuristicLab.FixedOperators/3.2/HeuristicLab.FixedOperators-3.2.csproj	(revision 1788)
+++ /trunk/sources/HeuristicLab.FixedOperators/3.2/HeuristicLab.FixedOperators-3.2.csproj	(revision 1789)
@@ -100,12 +100,8 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="FixedAllSGAMain.cs" />
-    <Compile Include="CreateReplacement.cs" />
-    <Compile Include="CreateChildrenHardWired.cs" />
-    <Compile Include="FixedBase.cs" />
+    <Compile Include="FixedOperatorBase.cs" />
     <Compile Include="FixedSGAMain.cs" />
     <Compile Include="HeuristicLabFixedOperatorsPlugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="CreateChildren.cs" />
   </ItemGroup>
   <ItemGroup>
