source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/ReferenceQualityAnalyzer.cs @ 5740

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

namespace HeuristicLab.Problems.MetaOptimization {
  /// <summary>
  /// TODO
  /// </summary>
  [Item("ReferenceQualityAnalyzer", "")]
  [StorableClass]
  public sealed class ReferenceQualityAnalyzer : SingleSuccessorOperator, IAnalyzer {
    
    public ValueLookupParameter<ResultCollection> ResultsParameter {
      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
    }
    public ScopeTreeLookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
      get { return (ScopeTreeLookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
    }
    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
    }
    public LookupParameter<DoubleArray> ProblemQualityReferenceParameter {
      get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityReferences"]; }
    }
    public LookupParameter<ConstrainedItemList<IProblem>> ProblemsParameter {
      get { return (LookupParameter<ConstrainedItemList<IProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
    }

    public ReferenceQualityAnalyzer()
      : base() {
      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", ""));
      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", ""));
      Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", ""));
      Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityReferences", ""));
      Parameters.Add(new LookupParameter<ConstrainedItemList<IProblem>>(MetaOptimizationProblem.ProblemsParameterName, ""));
    }

    [StorableConstructor]
    private ReferenceQualityAnalyzer(bool deserializing) : base(deserializing) { }
    private ReferenceQualityAnalyzer(ReferenceQualityAnalyzer original, Cloner cloner) : base(original, cloner) { }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ReferenceQualityAnalyzer(this, cloner);
    }

    public override IOperation Apply() {
      ResultCollection results = ResultsParameter.ActualValue;
      ItemArray<ParameterConfigurationTree> solutions = ParameterConfigurationParameter.ActualValue;
      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;

      if (ProblemQualityReferenceParameter.ActualValue == null) {
        DoubleArray referenceQualities = CalculateReferenceQualities(solutions);
        ProblemQualityReferenceParameter.ActualValue = referenceQualities;
        NormalizePopulation(solutions, qualities, referenceQualities);
        results.Add(new Result("QualityReferences", referenceQualities));
      }

      return base.Apply();
    }

    private DoubleArray CalculateReferenceQualities(ItemArray<ParameterConfigurationTree> solutions) {
      DoubleArray referenceQualities = new DoubleArray(ProblemsParameter.ActualValue.Count);
      for (int pi = 0; pi < ProblemsParameter.ActualValue.Count; pi++) {
        referenceQualities[pi] = solutions.Where(x => x.AverageQualities != null).Select(x => x.AverageQualities[pi]).Min(); // todo: respect minimization / maximization
      }
      return referenceQualities;
    }

    private void NormalizePopulation(ItemArray<ParameterConfigurationTree> solutions, ItemArray<DoubleValue> qualities, DoubleArray referenceQualities) {
      for (int i = 0; i < solutions.Length; i++) {
        qualities[i].Value = MetaOptimizationUtil.NormalizeQualities(solutions[i], referenceQualities.ToArray());
      }
    }
  }
}