source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationTree.cs @ 5023

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Core;
using HeuristicLab.Common;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Optimization;
using HeuristicLab.Data;

namespace HeuristicLab.Problems.MetaOptimization {
  // todo: storable, name, descr, ...
  [StorableClass]
  public class ParameterConfigurationTree : ValueConfiguration {
    [Storable]
    public EngineAlgorithm Algorithm {
      get { return (EngineAlgorithm)base.ActualValue.Value; }
      set {
        base.ActualValue.Value = value;
      }
    }

    [Storable]
    private DoubleValue bestQuality;
    public DoubleValue BestQuality {
      get { return bestQuality; }
      set {
        if (bestQuality != value) {
          if (bestQuality != null) DeregisterQualityEvents();
          bestQuality = value;
          if (bestQuality != null) RegisterQualityEvents();
          OnQualityChanged();
        }
      }
    }

    [Storable]
    private DoubleValue averageQuality;
    public DoubleValue AverageQuality {
      get { return averageQuality; }
      set { averageQuality = value; }
    }

    [Storable]
    private DoubleValue worstQuality;
    public DoubleValue WorstQuality {
      get { return worstQuality; }
      set { worstQuality = value; }
    }
    
    [Storable]
    private DoubleValue qualityVariance;
    public DoubleValue QualityVariance {
      get { return qualityVariance; }
      set { qualityVariance = value; }
    }
    
    [Storable]
    private DoubleValue qualityStandardDeviation;
    public DoubleValue QualityStandardDeviation {
      get { return qualityStandardDeviation; }
      set { qualityStandardDeviation = value; }
    }
    
    [Storable]
    private TimeSpanValue averageExecutionTime;
    public TimeSpanValue AverageExecutionTime {
      get { return averageExecutionTime; }
      set { averageExecutionTime = value; }
    }

    [Storable]
    private IntValue repetitions;
    public IntValue Repetitions {
      get { return repetitions; }
      set { repetitions = value; }
    }

    [Storable]
    public RunCollection Runs { get; set; }
    
    #region constructors and cloning
    public ParameterConfigurationTree(EngineAlgorithm algorithm) : base(algorithm, algorithm.GetType()) {
      this.Optimize = true; // root must always be optimized
      this.BestQuality = new DoubleValue();
    }
    public ParameterConfigurationTree() {
      Initialize();
    }
    [StorableConstructor]
    protected ParameterConfigurationTree(bool deserializing) : base(deserializing) { }
    protected ParameterConfigurationTree(ParameterConfigurationTree original, Cloner cloner) : base(original, cloner) {
      this.bestQuality = cloner.Clone(original.BestQuality);
      this.Algorithm.Prepare();
      this.Algorithm.Runs.Clear();
      Initialize();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ParameterConfigurationTree(this, cloner);
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      Initialize();
    }
    #endregion

    private void Initialize() {
      //if (algorithm != null) RegisterAlgorithmEvents();
      if (bestQuality != null) RegisterQualityEvents();
    }

    public virtual void CollectResultValues(IDictionary<string, IItem> values) {
      values.Add("RunsAverageExecutionTime", AverageExecutionTime);
      values.Add("Repetitions", Repetitions);
      values.Add("RunsBestQuality", BestQuality);
      values.Add("RunsAverageQuality", AverageQuality);
      values.Add("RunsWorstQuality", WorstQuality);
      values.Add("RunsQualityVariance", QualityVariance);
      values.Add("RunsQualityStandardDeviation", QualityStandardDeviation);
      values.Add("Runs", Runs);
    }

    #region Events
    //public event EventHandler AlgorithmChanged;
    //private void OnAlgorithmChanged() {
    //  var handler = AlgorithmChanged;
    //  if (handler != null) handler(this, EventArgs.Empty);
    //}
    public event EventHandler QualityChanged;
    private void OnQualityChanged() {
      var handler = QualityChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    //private void RegisterAlgorithmEvents() {
      
    //}
    //private void DeregisterAlgorithmEvents() {

    //}
    private void RegisterQualityEvents() {
      BestQuality.ValueChanged += new EventHandler(Quality_ValueChanged);
    }
    private void DeregisterQualityEvents() {
      BestQuality.ValueChanged -= new EventHandler(Quality_ValueChanged);
    }

    private void Quality_ValueChanged(object sender, EventArgs e) {
      OnQualityChanged();
    }
    #endregion

  }
}