Index: trunk/sources/HeuristicLab.Operators/3.3/SubScopesProcessor.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/SubScopesProcessor.cs	(revision 3702)
+++ trunk/sources/HeuristicLab.Operators/3.3/SubScopesProcessor.cs	(revision 3710)
@@ -20,4 +20,5 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -25,14 +26,19 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+using System;
 
 namespace HeuristicLab.Operators {
   /// <summary>
-  /// An operator which contains multiple operators of which each is applied on one sub-scope of the current scope. The first operator is applied on the first sub-scope, the second on the second, and so on.
+  /// An operator which contains multiple operators of which each is applied on one sub-scope at the given depth of the current scope. The first operator is applied on the first sub-scope, the second on the second, and so on.
   /// </summary>
-  [Item("SubScopesProcessor", "An operator which contains multiple operators of which each is applied on one sub-scope of the current scope. The first operator is applied on the first sub-scope, the second on the second, and so on.")]
+  [Item("SubScopesProcessor", "An operator which contains multiple operators of which each is applied on one sub-scope at the given depth of the current scope. The first operator is applied on the first sub-scope, the second on the second, and so on.")]
   [StorableClass]
   public sealed class SubScopesProcessor : MultiOperator<IOperator> {
     public ValueLookupParameter<BoolValue> ParallelParameter {
       get { return (ValueLookupParameter<BoolValue>)Parameters["Parallel"]; }
+    }
+    public ValueParameter<IntValue> DepthParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Depth"]; }
     }
 
@@ -41,21 +47,38 @@
       set { ParallelParameter.Value = value; }
     }
+    public IntValue Depth {
+      get { return DepthParameter.Value; }
+      set { DepthParameter.Value = value; }
+    }
 
     public SubScopesProcessor()
       : base() {
       Parameters.Add(new ValueLookupParameter<BoolValue>("Parallel", "True if the operators should be applied in parallel on the sub-scopes, otherwise false.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<IntValue>("Depth", "The number of steps to descend in the scope tree before applying operator.", new IntValue(1)));
     }
 
     public override IOperation Apply() {
-      BoolValue parallel = ParallelParameter.ActualValue;
+      List<IScope> scopes = GetScopesOnLevel(ExecutionContext.Scope, Depth.Value).ToList();
       OperationCollection next = new OperationCollection(base.Apply());
-      if (Operators.Count > 0) {
-        OperationCollection inner = new OperationCollection();
-        inner.Parallel = parallel == null ? false : parallel.Value;
-        for (int i = 0; (i < ExecutionContext.Scope.SubScopes.Count) && (i < Operators.Count); i++)
-          if (Operators[i] != null) inner.Add(ExecutionContext.CreateOperation(Operators[i], ExecutionContext.Scope.SubScopes[i]));
-        next.Insert(0, inner);
+      if (scopes.Count != Operators.Count)
+        throw new ArgumentException("The number of operators doesn't match the number of sub-scopes at depth " + Depth.Value);
+      OperationCollection inner = new OperationCollection();
+      inner.Parallel = Parallel == null ? false : Parallel.Value;
+      for (int i = 0; i < scopes.Count(); i++) {
+        inner.Add(ExecutionContext.CreateOperation(Operators[i], scopes[i]));
       }
+      next.Insert(0, inner);
       return next;
+    }
+
+    private IEnumerable<IScope> GetScopesOnLevel(IScope scope, int d) {
+      if (d == 0) yield return scope;
+      else {
+        foreach (IScope subScope in scope.SubScopes) {
+          foreach (IScope scopesOfSubScope in GetScopesOnLevel(subScope, d - 1)) {
+            yield return scopesOfSubScope;
+          }
+        }
+      }
     }
   }
Index: trunk/sources/HeuristicLab.Operators/3.3/UniformSubScopesProcessor.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/UniformSubScopesProcessor.cs	(revision 3702)
+++ trunk/sources/HeuristicLab.Operators/3.3/UniformSubScopesProcessor.cs	(revision 3710)
@@ -25,10 +25,13 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+using System;
+using System.Linq;
 
 namespace HeuristicLab.Operators {
   /// <summary>
-  /// An operator which applies a specified operator on all sub-scopes of the current scope.
+  /// An operator which applies a specified operator on all sub-scopes at the given depth of the current scope.
   /// </summary>
-  [Item("UniformSubScopesProcessor", "An operator which applies a specified operator on all sub-scopes of the current scope.")]
+  [Item("UniformSubScopesProcessor", "An operator which applies a specified operator on all sub-scopes at the given depth of the current scope.")]
   [StorableClass]
   public sealed class UniformSubScopesProcessor : SingleSuccessorOperator {
@@ -38,4 +41,7 @@
     public ValueLookupParameter<BoolValue> ParallelParameter {
       get { return (ValueLookupParameter<BoolValue>)Parameters["Parallel"]; }
+    }
+    public ValueParameter<IntValue> DepthParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Depth"]; }
     }
 
@@ -48,4 +54,8 @@
       set { ParallelParameter.Value = value; }
     }
+    public IntValue Depth {
+      get { return DepthParameter.Value; }
+      set { DepthParameter.Value = value; }
+    }
 
     public UniformSubScopesProcessor()
@@ -53,18 +63,31 @@
       Parameters.Add(new OperatorParameter("Operator", "The operator which should be applied on all sub-scopes of the current scope."));
       Parameters.Add(new ValueLookupParameter<BoolValue>("Parallel", "True if the operator should be applied in parallel on all sub-scopes, otherwise false.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<IntValue>("Depth", "The number of steps to descend in the scope tree before applying operator.", new IntValue(1)));
     }
 
     public override IOperation Apply() {
-      BoolValue parallel = ParallelParameter.ActualValue;
       OperationCollection next = new OperationCollection(base.Apply());
       if (Operator != null) {
+        List<IScope> scopes = GetScopesOnLevel(ExecutionContext.Scope, Depth.Value).ToList();
         OperationCollection inner = new OperationCollection();
-        inner.Parallel = parallel == null ? false : parallel.Value;
-        for (int i = 0; i < ExecutionContext.Scope.SubScopes.Count; i++)
-          inner.Add(ExecutionContext.CreateOperation(Operator, ExecutionContext.Scope.SubScopes[i]));
+        inner.Parallel = Parallel == null ? false : Parallel.Value;
+        for (int i = 0; i < scopes.Count; i++) {
+          inner.Add(ExecutionContext.CreateOperation(Operator, scopes[i]));
+        }
         next.Insert(0, inner);
       }
       return next;
     }
+
+    private IEnumerable<IScope> GetScopesOnLevel(IScope scope, int d) {
+      if (d == 0) yield return scope;
+      else {
+        foreach (IScope subScope in scope.SubScopes) {
+          foreach (IScope scopesOfSubScope in GetScopesOnLevel(subScope, d - 1)) {
+            yield return scopesOfSubScope;
+          }
+        }
+      }
+    }
   }
 }
