source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs @ 4982

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;

namespace HeuristicLab.Problems.MetaOptimization {
  [Item("Meta Optimization Problem", "Represents a Meta Optimization Problem.")]
  [Creatable("Problems")]
  [StorableClass]
  public sealed class MetaOptimizationProblem : SingleObjectiveProblem<IMetaOptimizationEvaluator, IParameterConfigurationCreator> {
    private const string AlgorithmParameterName = "Algorithm";
    private const string ProblemsParameterName = "Problems";
    private const string AlgorithmParameterConfigurationParameterName = "AlgorithmParameterConfiguration";
    private const string ProblemParametersConfigurationParameterName = "ProblemParametersConfiguration";

    #region Parameter Properties
    public ValueParameter<IAlgorithm> AlgorithmParameter {
      get { return (ValueParameter<IAlgorithm>)Parameters[AlgorithmParameterName]; }
    }
    public ValueParameter<IItemList<ISingleObjectiveProblem>> ProblemsParameter {
      get { return (ValueParameter<IItemList<ISingleObjectiveProblem>>)Parameters[ProblemsParameterName]; }
    }
    public ValueParameter<IValueConfiguration> AlgorithmParameterConfigurationParameter {
      get { return (ValueParameter<IValueConfiguration>)Parameters[AlgorithmParameterConfigurationParameterName]; }
    }
    //public ValueParameter<IItemList<IParameterConfiguration>> ProblemParametersConfigurationParameter {
    //  get { return (ValueParameter<IItemList<IParameterConfiguration>>)Parameters[ProblemParametersConfigurationParameterName]; }
    //}
    #endregion

    #region Properties
    public IAlgorithm Algorithm {
      get { return AlgorithmParameter.Value; }
      set { AlgorithmParameter.Value = value; }
    }
    public IItemList<ISingleObjectiveProblem> Problems {
      get { return ProblemsParameter.Value; }
      set { ProblemsParameter.Value = value; }
    }
    public IValueConfiguration AlgorithmParameterConfiguration {
      get { return AlgorithmParameterConfigurationParameter.Value; }
      set { AlgorithmParameterConfigurationParameter.Value = value; }
    }
    //public IItemList<IParameterConfiguration> ProblemParametersConfiguration {
    //  get { return ProblemParametersConfigurationParameter.Value; }
    //  set { ProblemParametersConfigurationParameter.Value = value; }
    //}
    #endregion

    public MetaOptimizationProblem()
      : base() {
      Parameters.Add(new ValueParameter<IAlgorithm>(AlgorithmParameterName, "The algorithm which's parameters should be optimized."));
      Parameters.Add(new ValueParameter<IItemList<IProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ItemList<IProblem>()));
      Parameters.Add(new ValueParameter<IValueConfiguration>(AlgorithmParameterConfigurationParameterName, "List of algorithm parameters that should be optimized."));
      //Parameters.Add(new ValueParameter<IItemList<IParameterConfiguration>>(ProblemParametersConfigurationParameterName, "List of problem parameters that should be optimized.", new ItemList<IParameterConfiguration>()));
      
      Maximization = new BoolValue(false);
      SolutionCreator = new RandomParameterConfigurationCreator();
      Evaluator = new MetaOptimizationEvaluator();

      InitializeOperators();
      RegisterParameterEvents();
      ParameterizeSolutionCreator();
      ParameterizeEvaluator();
      ParameterizeOperators();
    }

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

    #region Helpers
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserializationHook() {
      RegisterParameterEvents();
    }
    private void RegisterParameterEvents() {
      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
      EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
      AlgorithmParameter.ValueChanged += new EventHandler(BaseLevelAlgorithmParameter_ValueChanged);
    }
    private void InitializeOperators() {
      Operators.AddRange(ApplicationManager.Manager.GetInstances<IParameterConfigurationOperator>().Cast<IOperator>());
      Operators.Add(new BestParameterConfigurationAnalyzer());
    }
    private void ParameterizeSolutionCreator() {
      //SolutionCreator.ParametersToOptimize = this.ParametersToOptimize;
    }
    private void ParameterizeEvaluator() {
      ((MetaOptimizationEvaluator)Evaluator).ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
    }
    private void ParameterizeAnalyzer() {
      //BestQualityAnalyzer.ResultsParameter.ActualName = "Results";
    }
    private void ParameterizeOperators() {
      
    }

    #endregion

    #region Events

    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
      ParameterizeSolutionCreator();
      ParameterizeEvaluator();
      ParameterizeAnalyzer();
      ParameterizeOperators();
      OnSolutionCreatorChanged();
    }
    private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
      ParameterizeEvaluator();
      ParameterizeAnalyzer();
      OnEvaluatorChanged();
    }
    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
      ParameterizeAnalyzer();
    }
    void BaseLevelAlgorithmParameter_ValueChanged(object sender, EventArgs e) {
      if (Algorithm != null) {
        Algorithm.ProblemChanged += new EventHandler(BaseLevelAlgorithm_ProblemChanged);
        AlgorithmParameterConfiguration = new RootValueConfiguration(Algorithm, Algorithm.GetType());
      }
      BaseLevelAlgorithm_ProblemChanged(sender, e);
    }

    void BaseLevelAlgorithm_ProblemChanged(object sender, EventArgs e) {
      //ClearProblemParameters();
      //if (Algorithm.Problem != null) {
      //  AddProblemParameters();
      //}
    }
    #endregion
  }
}