source: addons/HeuristicLab.Problems.BioBoost/HeuristicLab.Problems.BioBoost/3.3/Analysis/MultiObjejctiveBioBoostSolutionAnalyzer.cs @ 17777

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 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.Diagnostics;
using HeuristicLab.BioBoost.ProblemDescription;
using HeuristicLab.BioBoost.Representation;
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.Linq;
using HeuristicLab.BioBoost.Utils;
using HEAL.Attic;

namespace HeuristicLab.BioBoost.Analysis {

  [Item("MultiObjectiveBioBoostSolutionAnalyzer", "An operator for analyzing the set of best bioboost solutions (multi objective).")]
  [StorableType("FC868394-A817-4835-845C-DD32562AE60C")]
  public class MultiObjectiveBioBoostSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer {

    public bool EnabledByDefault { get { return true; } }

    #region Parameters
    public LookupParameter<BoolArray> MaximizationParameter {
      get { return (LookupParameter<BoolArray>) Parameters["Maximization"]; }
    }
    public ScopeTreeLookupParameter<DoubleArray> QualitiesParameter {
      get { return (ScopeTreeLookupParameter<DoubleArray>) Parameters["QualityCriteria"]; }
    } 
    public LookupParameter<BioBoostProblemData> ProblemDataParameter {
      get { return (LookupParameter<BioBoostProblemData>) Parameters["ProblemData"]; }
    }
    public LookupParameter<ItemCollection<BioBoostCompoundSolution>> BestSolutionsParameter {
      get { return (LookupParameter<ItemCollection<BioBoostCompoundSolution>>) Parameters["BestSolutions"]; }
    }
    public ValueLookupParameter<ResultCollection> ResultsParameter {
      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
    }
    /*public LookupParameter<DoubleValue> BestKnownQualityParameter {
      get { return (LookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
    }
    public LookupParameter<BioBoostCompoundSolution> BestKnownSolutionParameter {
      get { return (LookupParameter<BioBoostCompoundSolution>)Parameters["BestKnownSolution"]; }
    } */
    /* public LookupParameter<ItemCollection<BioBoostCompoundSolution>> SolutionHistoryParameter {
      get { return (LookupParameter<ItemCollection<BioBoostCompoundSolution>>)Parameters["SolutionHistory"]; }
    } 
    public ValueLookupParameter<BoolValue> TrackHistoryParameter {
      get { return (ValueLookupParameter<BoolValue>) Parameters["TrackHistory"]; }
    } */
    #endregion

    #region Parameter Values
    public BoolArray Maximization {
      get { return MaximizationParameter.ActualValue;  }
    }
    public BioBoostProblemData ProblemData {
      get { return ProblemDataParameter.ActualValue; }
    }
    public ItemCollection<BioBoostCompoundSolution> BestSolutions {
      get { return BestSolutionsParameter.ActualValue; }
      set { BestSolutionsParameter.ActualValue = value; }
    }
    // private bool TrackHistory { get { return TrackHistoryParameter.ActualValue.Value;  } }
    #endregion

    #region Construction & Cloning
    [StorableConstructor]
    protected MultiObjectiveBioBoostSolutionAnalyzer(StorableConstructorFlag _) : base(_) { }
    protected MultiObjectiveBioBoostSolutionAnalyzer(MultiObjectiveBioBoostSolutionAnalyzer orig, Cloner cloner) : base(orig, cloner) {}
    public MultiObjectiveBioBoostSolutionAnalyzer() {
      Parameters.Add(new LookupParameter<BoolArray>("Maximization", "Whether this is a maximization problem."));
      Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>("QualityCriteria", "The list of quality criteria."));
      Parameters.Add(new LookupParameter<BioBoostProblemData>("ProblemData", "The collection of problem data."));
      Parameters.Add(new LookupParameter<ItemCollection<BioBoostCompoundSolution>>("BestSolutions", "Pareto set of best solutions.."));
      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the best solution should be stored."));
      /* Parameters.Add(new LookupParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this instance."));
      Parameters.Add(new LookupParameter<BioBoostCompoundSolution>("BestKnownSolution", "The best known solution of this instance."));
      Parameters.Add(new LookupParameter<ItemCollection<BioBoostCompoundSolution>>("SolutionHistory", "The history of best solutions over time."));
      Parameters.Add(new ValueLookupParameter<BoolValue>("TrackHistory", "True if all best solutions (over time) should be recorded in SolutionHistory", new BoolValue(false))); */
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MultiObjectiveBioBoostSolutionAnalyzer(this, cloner);
    }
    #endregion

    public override IOperation Apply() {
      var qualities = QualitiesParameter.ActualValue.Select((q, i) => new {q, i}).ToList();
      var maximization = Maximization;
      var bestQualities =
        qualities.Where(q1 => qualities.All(q2 => q1.i == q2.i || !IsDominating(q2.q, q1.q, maximization)))
        .GroupBy(q => q.q, q => q, Enumerable.SequenceEqual).Select(g => g.First());
      IResult bestSolutionsResult = null;
      ItemCollection<BioBoostCompoundSolution> bestSolutions = null;
      if (!ResultsParameter.ActualValue.TryGetValue("BestSolutions", out bestSolutionsResult)) {
        bestSolutions = new ItemCollection<BioBoostCompoundSolution>();
        ResultsParameter.ActualValue.Add(new Result("BestSolutions", bestSolutions));
      } else {
        bestSolutions = bestSolutionsResult.Value as ItemCollection<BioBoostCompoundSolution>;
        if (bestSolutions != null) {
          bestSolutions.Clear();
        }
      }
      if (bestSolutions == null)
        throw new InvalidOperationException("BestSolutions in Results has wrong type and cannot be updated.");
      var solutions = bestQualities
        .OrderByDescending(q => q.q[0])
        .Select(q => new BioBoostCompoundSolution(ExecutionContext.Scope.SubScopes[q.i], ProblemData) {
                       Name = string.Format("[{0}]", string.Join(", ", q.q))})
        .ToList();
      bestSolutions.AddRange(solutions);
      return base.Apply();
    }

    private static bool IsDominating(DoubleArray a, DoubleArray b, BoolArray maximization) {
      Debug.Assert(a.Length == b.Length);
      for (int i = 0; i < a.Length; i++) {
        if (maximization[i]) {
          if (a[i] <= b[i]) return false;
        } else {
          if (a[i] >= b[i]) return false;
        }
      }
      return true;
    }

  }
}