Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs	(revision 13482)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs	(revision 13495)
@@ -314,6 +314,5 @@
       }
       // update qualities for intermediate vertices
-      if (!TrimOlderGenerations)
-        EvaluateIntermediateChildren();
+      EvaluateIntermediateChildren();
 
       // remove extra graph nodes (added by the instrumented operators in the case of offspring selection)
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs	(revision 13482)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs	(revision 13495)
@@ -105,20 +105,14 @@
       var vertices = population.Select(graph.GetByContent).ToList();
       DataTable table;
-      double aac = 0; // ratio of above average children produced
-      double aacp = 0; // ratio of above average children from above average parents
       #region crossover improvement
       if (!Results.ContainsKey("Crossover improvement")) {
         table = new DataTable("Crossover improvement");
         Results.Add(new Result("Crossover improvement", table));
-        table.Rows.AddRange(new[]
-          {
-              new DataRow("Average crossover improvement (root parent)") { VisualProperties = { StartIndexZero = true } },
-              new DataRow("Average crossover improvement (non-root parent)") { VisualProperties = { StartIndexZero = true } },
-              new DataRow("Average child-parents quality difference") { VisualProperties = { StartIndexZero = true } },
-              new DataRow("Best crossover improvement (root parent)") { VisualProperties = { StartIndexZero = true } },
-              new DataRow("Best crossover improvement (non-root parent)") { VisualProperties = { StartIndexZero = true }},
-              new DataRow("Above average children") { VisualProperties = { StartIndexZero = true }},
-              new DataRow("Above average children from above average parents") { VisualProperties = { StartIndexZero = true } },
-            });
+        table.Rows.AddRange(new[] {
+          new DataRow("Average crossover child quality") { VisualProperties = { StartIndexZero = true } },
+          new DataRow("Average crossover parent quality") { VisualProperties = { StartIndexZero = true } },
+          new DataRow("Best crossover child quality") { VisualProperties = { StartIndexZero = true } },
+          new DataRow("Best crossover parent quality") { VisualProperties = { StartIndexZero = true } },
+        });
       } else {
         table = (DataTable)Results["Crossover improvement"].Value;
@@ -128,23 +122,14 @@
         crossoverChildren.AddRange(vertices.Where(x => x.InDegree == 1).Select(v => v.Parents.First()).Where(p => p.Rank.IsAlmost(generation - 0.5))); // add intermediate children
 
-      foreach (var c in crossoverChildren) {
-        if (c.Quality > averageQuality) {
-          aac++;
-          if (c.Parents.All(x => x.Quality > averageQuality))
-            aacp++;
-        }
-      }
-      var avgRootParentQualityImprovement = crossoverChildren.Average(x => x.Quality - x.Parents.First().Quality);
-      var avgNonRootParentQualityImprovement = crossoverChildren.Average(x => x.Quality - x.Parents.Last().Quality);
-      var avgChildParentQuality = crossoverChildren.Average(x => x.Quality - x.Parents.Average(p => p.Quality));
-      var bestRootParentQualityImprovement = crossoverChildren.Max(x => x.Quality - x.Parents.First().Quality);
-      var bestNonRootParentQualityImprovement = crossoverChildren.Max(x => x.Quality - x.Parents.Last().Quality);
-      table.Rows["Average crossover improvement (root parent)"].Values.Add(avgRootParentQualityImprovement);
-      table.Rows["Average crossover improvement (non-root parent)"].Values.Add(avgNonRootParentQualityImprovement);
-      table.Rows["Best crossover improvement (root parent)"].Values.Add(bestRootParentQualityImprovement);
-      table.Rows["Best crossover improvement (non-root parent)"].Values.Add(bestNonRootParentQualityImprovement);
-      table.Rows["Average child-parents quality difference"].Values.Add(avgChildParentQuality);
-      table.Rows["Above average children"].Values.Add(aac / populationSize);
-      table.Rows["Above average children from above average parents"].Values.Add(aacp / populationSize);
+      var avgCrossoverParentQuality = crossoverChildren.SelectMany(x => x.Parents).Average(x => x.Quality);
+      var avgCrossoverChildQuality = crossoverChildren.Average(x => x.Quality);
+
+      var bestCrossoverChildQuality = crossoverChildren.OrderBy(x => x.Quality).Last().Quality;
+      var bestCrossoverParentQuality = crossoverChildren.OrderBy(x => x.Quality).Last().Parents.First().Quality;
+
+      table.Rows["Average crossover child quality"].Values.Add(avgCrossoverChildQuality);
+      table.Rows["Average crossover parent quality"].Values.Add(avgCrossoverParentQuality);
+      table.Rows["Best crossover child quality"].Values.Add(bestCrossoverChildQuality);
+      table.Rows["Best crossover parent quality"].Values.Add(bestCrossoverParentQuality);
       #endregion
 
@@ -153,33 +138,27 @@
         table = new DataTable("Mutation improvement");
         Results.Add(new Result("Mutation improvement", table));
-        table.Rows.AddRange(new[]
-          {
-              new DataRow("Average mutation improvement") { VisualProperties = { StartIndexZero = true } },
-              new DataRow("Best mutation improvement") { VisualProperties = { StartIndexZero = true } },
-              new DataRow("Above average children") { VisualProperties = { StartIndexZero = true } },
-              new DataRow("Above average children from above average parents") { VisualProperties = { StartIndexZero = true } },
-            });
+        table.Rows.AddRange(new[] {
+          new DataRow("Average mutation child quality") { VisualProperties = { StartIndexZero = true } },
+          new DataRow("Average mutation parent quality") { VisualProperties = { StartIndexZero = true } },
+          new DataRow("Best mutation child quality") { VisualProperties = { StartIndexZero = true } },
+          new DataRow("Best mutation parent quality") { VisualProperties = { StartIndexZero = true } },
+        });
       } else {
         table = (DataTable)Results["Mutation improvement"].Value;
       }
 
-      aac = 0;
-      aacp = 0;
       var mutationChildren = vertices.Where(x => x.InDegree == 1).ToList();
 
-      foreach (var c in mutationChildren) {
-        if (c.Quality > averageQuality) {
-          aac++;
-          if (c.Parents.All(x => x.Quality > averageQuality))
-            aacp++;
-        }
-      }
-      var avgMutationImprovement = mutationChildren.Average(x => x.Quality - x.Parents.First().Quality);
-      var bestMutationImprovement = mutationChildren.Max(x => x.Quality - x.Parents.First().Quality);
+      var avgMutationParentQuality = mutationChildren.SelectMany(x => x.Parents).Average(x => x.Quality);
+      var avgMutationChildQuality = mutationChildren.Average(x => x.Quality);
 
-      table.Rows["Average mutation improvement"].Values.Add(avgMutationImprovement);
-      table.Rows["Best mutation improvement"].Values.Add(bestMutationImprovement);
-      table.Rows["Above average children"].Values.Add(aac / populationSize);
-      table.Rows["Above average children from above average parents"].Values.Add(aacp / populationSize);
+      var bestMutationChildQuality = mutationChildren.OrderBy(x => x.Quality).Last().Quality;
+      var bestMutationParentQuality = mutationChildren.OrderBy(x => x.Quality).Last().Parents.First().Quality;
+
+      table.Rows["Average mutation child quality"].Values.Add(avgMutationChildQuality);
+      table.Rows["Average mutation parent quality"].Values.Add(avgMutationParentQuality);
+      table.Rows["Best mutation child quality"].Values.Add(bestMutationChildQuality);
+      table.Rows["Best mutation parent quality"].Values.Add(bestMutationParentQuality);
+
       #endregion
       return base.Apply();
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/Analyzers/SymbolicDataAnalysisFragmentLengthAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/Analyzers/SymbolicDataAnalysisFragmentLengthAnalyzer.cs	(revision 13482)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/Analyzers/SymbolicDataAnalysisFragmentLengthAnalyzer.cs	(revision 13495)
@@ -61,11 +61,29 @@
       updateCounter.Value = 1;
 
-      if (PopulationGraph == null)
+      if (PopulationGraph == null || Generation.Value == 0)
         return base.Apply();
 
-      var children = PopulationGraph.GetByRank(Generation.Value).Where(x => x.InDegree > 0).ToList();
-      double avgFragmentLength = 0;
-      if (children.Any())
-        avgFragmentLength = children.Select(x => (IFragment<ISymbolicExpressionTreeNode>)x.InArcs.Last().Data).Where(f => f != null).Average(x => x.Root.GetLength());
+      // consider all fragments (including those of the intermediate crossover children)
+      double averageCrossoverFragmentLength = 0;
+      double averageMutationFragmentLength = 0;
+      int crossoverChildren = 0;
+      int mutationChildren = 0;
+
+      var vertices = PopulationGraph.Vertices.Where(x => x.Rank > Generation.Value - 1);
+      foreach (var v in vertices) {
+        if (!v.InArcs.Any() || v.InArcs.Last().Data == null)
+          continue;
+        var fragment = (IFragment<ISymbolicExpressionTreeNode>)v.InArcs.Last().Data;
+        if (v.InDegree == 2) {
+          averageCrossoverFragmentLength += fragment.Root.GetLength();
+          crossoverChildren++;
+        } else {
+          averageMutationFragmentLength += fragment.Root.GetLength();
+          mutationChildren++;
+        }
+      }
+      var averageFragmentLength = (averageCrossoverFragmentLength + averageMutationFragmentLength) / (crossoverChildren + mutationChildren);
+      averageCrossoverFragmentLength /= crossoverChildren;
+      averageMutationFragmentLength /= mutationChildren;
 
       DataTable table;
@@ -73,10 +91,18 @@
         table = new DataTable("Average fragment length");
         var row = new DataRow("Average fragment length") { VisualProperties = { StartIndexZero = true } };
-        row.Values.Add(avgFragmentLength);
+        row.Values.Add(averageFragmentLength);
+        table.Rows.Add(row);
+        row = new DataRow("Average crossover fragment length") { VisualProperties = { StartIndexZero = true } };
+        row.Values.Add(averageCrossoverFragmentLength);
+        table.Rows.Add(row);
+        row = new DataRow("Average mutation fragment length") { VisualProperties = { StartIndexZero = true } };
+        row.Values.Add(averageMutationFragmentLength);
         table.Rows.Add(row);
         Results.Add(new Result("AverageFragmentLength", table));
       } else {
         table = (DataTable)Results["AverageFragmentLength"].Value;
-        table.Rows["Average fragment length"].Values.Add(avgFragmentLength);
+        table.Rows["Average fragment length"].Values.Add(averageFragmentLength);
+        table.Rows["Average crossover fragment length"].Values.Add(averageCrossoverFragmentLength);
+        table.Rows["Average mutation fragment length"].Values.Add(averageMutationFragmentLength);
       }
       return base.Apply();
