source: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs @ 10278

using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.EvolutionTracking {
  [StorableClass]
  [Item("GenealogyAnalyzer", "An analyzer which performs the necessary instrumentation to record the evolution of a genetic algorithm.")]
  public class GenealogyAnalyzer<TGraph, TVertex, TContent> : SingleSuccessorOperator, IAnalyzer
    where TGraph : class, IGenealogyGraph<TVertex, TContent>
    where TVertex : class, IGenealogyGraphNode<TContent>, new()
    where TContent : class, IItem {

    private AfterCrossoverOperator<TGraph, TVertex, TContent> afterCrossoverOperator;
    private AfterManipulatorOperator<TGraph, TVertex, TContent> afterManipulatorOperator;
    private BeforeManipulatorOperator<TGraph, TVertex, TContent> beforeManipulatorOperator;
    //    private AfterSolutionCreatorOperator<TGraph, TVertex, TContent> afterSolutionCreatorOperator;
    public string CrossoverParentsParameterName { get; set; }
    public string CrossoverChildParameterName { get; set; }
    public string ManipulatorChildParameterName { get; set; }

    private string solutionCreatorIndividualParameterName;
    public string SolutionCreatorIndividualParameterName {
      get { return solutionCreatorIndividualParameterName; }
      set {
        if (solutionCreatorIndividualParameterName != null && Parameters.ContainsKey(solutionCreatorIndividualParameterName)) {
          Parameters.Remove(solutionCreatorIndividualParameterName);
        }
        solutionCreatorIndividualParameterName = value;
        if (!Parameters.ContainsKey(solutionCreatorIndividualParameterName)) {
          Parameters.Add(new ScopeTreeLookupParameter<TContent>(solutionCreatorIndividualParameterName));
        }
      }
    }

    private const string GenerationsParameterName = "Generations";
    private const string ResultsParameterName = "Results";
    private const string PopulationGraphParameterName = "PopulationGraph";

    private const string CrossoverParameterName = "Crossover";
    private const string ManipulatorParameterName = "Mutator";
    private const string SolutionCreatorParameterName = "SolutionCreator";

    private const string EnableCrossoverTrackingParameterName = "EnableCrossoverTracking";
    private const string EnableManipulatorTrackingParameterName = "EnableManipulatorTracking";
    private const string EnableSolutionCreatorTrackingParameterName = "EnableSolutionCreatorTracking"; // should always be enabled. maybe superfluous

    #region parameter properties
    public ILookupParameter<ResultCollection> ResultsParameter {
      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
    }
    public IScopeTreeLookupParameter<TContent> PopulationParameter {
      get { return (IScopeTreeLookupParameter<TContent>)Parameters[solutionCreatorIndividualParameterName]; }
    }
    public ILookupParameter<IntValue> GenerationsParameter {
      get { return (ILookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
    }
    public IValueParameter<BoolValue> EnableCrossoverTrackingParameter {
      get { return (IValueParameter<BoolValue>)Parameters[EnableCrossoverTrackingParameterName]; }
    }
    public IValueParameter<BoolValue> EnableManipulatorTrackingParameter {
      get { return (IValueParameter<BoolValue>)Parameters[EnableManipulatorTrackingParameterName]; }
    }
    public IValueParameter<BoolValue> EnableSolutionCreatorTrackingParameter {
      get { return (IValueParameter<BoolValue>)Parameters[EnableSolutionCreatorTrackingParameterName]; }
    }
    public ILookupParameter<ICrossover> CrossoverParameter {
      get { return (ILookupParameter<ICrossover>)Parameters[CrossoverParameterName]; }
    }
    public ILookupParameter<IManipulator> ManipulatorParameter {
      get { return (ILookupParameter<IManipulator>)Parameters[ManipulatorParameterName]; }
    }
    public ILookupParameter<ISolutionCreator> SolutionCreatorParameter {
      get { return (ILookupParameter<ISolutionCreator>)Parameters[SolutionCreatorParameterName]; }
    }
    public IntValue Generations {
      get { return GenerationsParameter.ActualValue; }
    }
    #endregion

    #region properties
    public ICrossover Crossover {
      get { return CrossoverParameter.ActualValue; }
    }
    public IManipulator Manipulator {
      get { return ManipulatorParameter.ActualValue; }
    }
    public ISolutionCreator SolutionCreator {
      get { return SolutionCreatorParameter.ActualValue; }
    }
    public BoolValue EnableCrossoverTracking {
      get { return EnableCrossoverTrackingParameter.Value; }
    }
    public BoolValue EnableManipulatorTracking {
      get { return EnableManipulatorTrackingParameter.Value; }
    }
    public BoolValue EnableSolutionCreatorTracking {
      get { return EnableSolutionCreatorTrackingParameter.Value; }
    }
    public ResultCollection Results {
      get { return ResultsParameter.ActualValue; }
    }
    public IGenealogyGraph<TVertex, TContent> GenealogyGraph {
      get {
        IResult result;
        if (!Results.ContainsKey(PopulationGraphParameterName)) {
          result = new Result(PopulationGraphParameterName, new GenealogyGraph<TVertex, TContent>());
          Results.Add(result);
        } else {
          result = Results[PopulationGraphParameterName];
        }
        var graph = (GenealogyGraph<TVertex, TContent>)result.Value;
        return graph;
      }
    }
    #endregion

    public GenealogyAnalyzer() {
      // the instrumented operators
      Parameters.Add(new LookupParameter<ICrossover>(CrossoverParameterName, "The crossover operator."));
      Parameters.Add(new LookupParameter<IManipulator>(ManipulatorParameterName, "The manipulator operator."));
      Parameters.Add(new LookupParameter<ISolutionCreator>(SolutionCreatorParameterName, "The solution creator operator."));
      // the analyzer parameters
      Parameters.Add(new ValueParameter<BoolValue>(EnableCrossoverTrackingParameterName, new BoolValue(true)));
      Parameters.Add(new ValueParameter<BoolValue>(EnableManipulatorTrackingParameterName, new BoolValue(true)));
      Parameters.Add(new ValueParameter<BoolValue>(EnableSolutionCreatorTrackingParameterName, new BoolValue(true)));
      // parameters required by the analyzer to do its work
      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName));
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new GenealogyAnalyzer<TGraph, TVertex, TContent>(this, cloner);
    }
    protected GenealogyAnalyzer(GenealogyAnalyzer<TGraph, TVertex, TContent> original, Cloner cloner)
      : base(original, cloner) {
    }

    public bool EnabledByDefault {
      get { return false; }
    }

    public override IOperation Apply() {
      // wire the before- and after operators
      //      if (EnableSolutionCreatorTracking.Value) {
      //        if (afterSolutionCreatorOperator == null) {
      //          afterSolutionCreatorOperator = new AfterSolutionCreatorOperator<TGraph, TVertex, TContent>();
      //          afterSolutionCreatorOperator.NewIndividualParameterName = SolutionCreatorIndividualParameterName;
      //        }
      //        var instrumentedSolutionCreator = (InstrumentedOperator)SolutionCreator;
      //        instrumentedSolutionCreator.AfterExecutionOperators.Add(afterSolutionCreatorOperator);
      //      }

      if (Generations.Value == 0) {
        foreach (var individual in PopulationParameter.ActualValue) {
          var vertex = new TVertex {
            Content = individual,
            Rank = Generations.Value
          };
          GenealogyGraph.AddVertex(vertex);
        }
      } else {
        // add missing individuals in the current generation
        foreach (var individual in PopulationParameter.ActualValue) {
          if (!GenealogyGraph.Contains(individual)) continue;
          // it is an elite which was already added to the graph in the previous generation
          var vertex = new TVertex {
            Content = individual,
            Rank = Generations.Value
          };
          GenealogyGraph.AddVertex(vertex);
        }
      }

      if (EnableCrossoverTracking.Value) {
        if (afterCrossoverOperator == null) {
          afterCrossoverOperator = new AfterCrossoverOperator<TGraph, TVertex, TContent>();
          afterCrossoverOperator.ParentsParameterName = CrossoverParentsParameterName;
          afterCrossoverOperator.ChildParameterName = CrossoverChildParameterName;
        }
        var instrumentedCrossover = (InstrumentedOperator)Crossover;
        instrumentedCrossover.AfterExecutionOperators.Add(afterCrossoverOperator);
      }

      if (EnableManipulatorTracking.Value) {
        if (beforeManipulatorOperator == null) {
          beforeManipulatorOperator = new BeforeManipulatorOperator<TGraph, TVertex, TContent>();
          beforeManipulatorOperator.ChildParameterName = ManipulatorChildParameterName;
        }
        if (afterManipulatorOperator == null) {
          afterManipulatorOperator = new AfterManipulatorOperator<TGraph, TVertex, TContent>();
          afterManipulatorOperator.ChildParameterName = ManipulatorChildParameterName;
        }
        var instrumentedManipulator = (InstrumentedOperator)Manipulator;
        instrumentedManipulator.BeforeExecutionOperators.Add(beforeManipulatorOperator);
        instrumentedManipulator.AfterExecutionOperators.Add(afterManipulatorOperator);
      }

      return base.Apply();
    }
  }
}