source: branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Operators/LineageAggregator.cs @ 9238

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.EvolutionaryTracking {
  /// <summary>
  /// This operator basically aggregates together a scope list of trees in the current generation and the genealogy graph so far
  /// in a new object that can be used as Content for the InteractiveIndividualHistoryView
  /// </summary>
  [StorableClass]
  public class GenealogyAggregator : SingleSuccessorOperator {
    private const string PopulationGraphParameterName = "PopulationGraph";
    private const string LineageExplorerParameterName = "LineageExplorer";
    private const string ResultsParameterName = "Results";
    private const string GenerationsParameterName = "Generations";
    private const string MaximumGenerationsParameterName = "MaximumGenerations";

    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
    private const string SymbolicExpressionTreeQualityParameterName = "Quality";

    #region Parameter properties
    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
    }
    public IScopeTreeLookupParameter<DoubleValue> SymbolicExpressionTreeQualityParameter {
      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[SymbolicExpressionTreeQualityParameterName]; }
    }
    public LookupParameter<ResultCollection> ResultsParameter {
      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
    }
    public LookupParameter<IntValue> GenerationsParameter {
      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
    }
    public LookupParameter<IntValue> MaximumGenerationsParameter {
      get { return (LookupParameter<IntValue>)Parameters[MaximumGenerationsParameterName]; }
    }
    #endregion
    #region Properties
    public bool EnabledByDefault {
      get { return true; }
    }
    public ResultCollection Results {
      get { return ResultsParameter.ActualValue; }
    }
    public IntValue Generations {
      get { return GenerationsParameter.ActualValue; }
    }
    public IntValue MaximumGenerations {
      get { return MaximumGenerationsParameter.ActualValue; }
    }
    #endregion

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() { }

    #region IStatefulItem members
    public override void InitializeState() {
      base.InitializeState();
    }

    public override void ClearState() {
      base.ClearState();
    }
    #endregion

    [StorableConstructor]
    private GenealogyAggregator(bool deserializing) : base(deserializing) { }
    private GenealogyAggregator(GenealogyAggregator original, Cloner cloner) : base(original, cloner) { }
    public override IDeepCloneable Clone(Cloner cloner) { return new GenealogyAggregator(this, cloner); }
    public GenealogyAggregator() {
      #region Add parameters
      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
      Parameters.Add(new LookupParameter<IntValue>(MaximumGenerationsParameterName, "The maximum number of generations"));
      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze"));
      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(SymbolicExpressionTreeQualityParameterName, "The qualities of the symbolic expression trees"));
      #endregion
    }

    public override IOperation Apply() {
      if (!Results.ContainsKey(PopulationGraphParameterName)) return base.Apply();
      var graph = (SymbolicExpressionTreeGenealogyGraph)Results[PopulationGraphParameterName].Value;
      var trees = SymbolicExpressionTreeParameter.ActualValue;
      var qualities = SymbolicExpressionTreeQualityParameter.ActualValue;
      var tuples = trees.Zip(qualities, (t, q) => new Tuple<ISymbolicExpressionTree, double>(t, q.Value)).ToList();
      var lineageExplorer = new LineageExplorer { GenealogyGraph = graph, Trees = tuples, Generations = Generations.Value };
      if (!Results.ContainsKey(LineageExplorerParameterName))
        Results.Add(new Result(LineageExplorerParameterName, lineageExplorer));
      else Results[LineageExplorerParameterName].Value = lineageExplorer; 

      return base.Apply();
    }
  }
}