source: branches/CFSAP/HeuristicLab.Problems.Scheduling.CFSAP/3.3/MultiNestCFSAPSolvingStrategy.cs @ 15472

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

namespace HeuristicLab.Problems.Scheduling.CFSAP {
  [Item("MultiNest CFSAP Solver", "Solving strategy that applies an algorithm instace to the worst nest.")]
  [StorableClass]
  [Creatable(CreatableAttribute.Categories.Algorithms)]
  public class MultiNestCFSAPSolvingStrategy : BasicAlgorithm {
    public override bool SupportsPause => true;

    public override Type ProblemType => typeof(MultiNestCFSAP);

    public new MultiNestCFSAP Problem {
      get { return (MultiNestCFSAP)base.Problem; }
      set { base.Problem = value; }
    }

    public IValueParameter<IAlgorithm> SolverParameter {
      get { return (IValueParameter<IAlgorithm>)Parameters["Solver"]; }
    }

    public IFixedValueParameter<TimeSpanValue> MaximumRuntimeParameter {
      get { return (IFixedValueParameter<TimeSpanValue>)Parameters["MaximumRuntime"]; }
    }


    public IFixedValueParameter<StringValue> EvaluatedSolutionsNameParameter {
      get { return (IFixedValueParameter<StringValue>)Parameters["EvaluatedSolutionsName"]; }
    }

    public IAlgorithm Solver {
      get { return SolverParameter.Value; }
      set { SolverParameter.Value = value; }
    }

    public TimeSpan MaximumRuntime {
      get { return MaximumRuntimeParameter.Value.Value; }
      set { MaximumRuntimeParameter.Value.Value = value; }
    }

    public string EvaluatedSolutionsName {
      get { return EvaluatedSolutionsNameParameter.Value.Value; }
      set { EvaluatedSolutionsNameParameter.Value.Value = value; }
    }

    [StorableConstructor]
    protected MultiNestCFSAPSolvingStrategy(bool deserializing) : base(deserializing) { }
    protected MultiNestCFSAPSolvingStrategy(MultiNestCFSAPSolvingStrategy original, Cloner cloner)
      : base(original, cloner) {
      if (original.algorithms != null)
        algorithms = original.algorithms.Select(x => cloner.Clone(x)).ToList();
      if (original.qualities != null)
        qualities = original.qualities.ToArray();
      if (original.algorithmsResults != null)
        algorithmsResults = cloner.Clone(original.algorithmsResults);
      if (original.qualityPerClock != null)
        qualityPerClock = cloner.Clone(original.qualityPerClock);
      if (original.qualityPerEvaluations != null)
        qualityPerEvaluations = cloner.Clone(original.qualityPerEvaluations);
    }
    public MultiNestCFSAPSolvingStrategy() {
      Parameters.Add(new ValueParameter<IAlgorithm>("Solver", "The actual solver template.") { GetsCollected = false });
      Parameters.Add(new FixedValueParameter<TimeSpanValue>("MaximumRuntime", "The maximum time that the strategy should run.", new TimeSpanValue(TimeSpan.FromSeconds(60))));
      Parameters.Add(new FixedValueParameter<StringValue>("EvaluatedSolutionsName", "The name of the result that shows the number of evaluated solutions by the actual solver.", new StringValue("EvaluatedSolutions")));
    }
    
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MultiNestCFSAPSolvingStrategy(this, cloner);
    }


    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (!Parameters.ContainsKey("EvaluatedSolutionsName"))
        Parameters.Add(new FixedValueParameter<StringValue>("EvaluatedSolutionsName", "The name of the result that shows the number of evaluated solutions by the actual solver.", new StringValue("EvaluatedSolutions")));
    }

    [Storable]
    private List<IAlgorithm> algorithms;
    [Storable]
    private int[] qualities;
    [Storable]
    private ResultCollection algorithmsResults;
    [Storable]
    private IndexedDataTable<double> qualityPerClock;
    [Storable]
    private IndexedDataTable<double> qualityPerEvaluations;

    protected override void OnPrepared() {
      base.OnPrepared();
      algorithms = null;
      qualities = null;
      algorithmsResults = null;
      qualityPerClock = null;
      qualityPerEvaluations = null;
    }

    protected override void Initialize(CancellationToken cancellationToken) {
      var nests = Problem.ProcessingTimesParameter.Value.Count;
      algorithms = new List<IAlgorithm>(nests);
      algorithmsResults = new ResultCollection();
      for (var n = 0; n < nests; n++) {
        var clone = (IAlgorithm)SolverParameter.Value.Clone();
        clone.Prepare();
        var cfsap = (ICFSAP)clone.Problem;
        cfsap.ProcessingTimes = Problem.ProcessingTimes[n];
        cfsap.SetupTimes = Problem.SetupTimes[n];
        cfsap.UpdateEncoding();
        algorithms.Add(clone);
        algorithmsResults.Add(new Result("Nest " + (n + 1), clone.Results));
        clone.Start();
      }
      qualities = algorithms.Select(x => (int)((DoubleValue)x.Results["BestQuality"].Value).Value).ToArray();
      var worst = qualities.Select((v, i) => new { Index = i, Quality = v }).MaxItems(x => x.Quality).First();
      var min = worst.Quality;

      qualityPerClock = new IndexedDataTable<double>("Quality per Clock");
      var qpcRow = new IndexedDataRow<double>("First-hit Graph");
      qpcRow.Values.Add(Tuple.Create(ExecutionTime.TotalSeconds, (double)min));
      qpcRow.Values.Add(Tuple.Create(ExecutionTime.TotalSeconds, (double)min));
      qualityPerClock.Rows.Add(qpcRow);
      qualityPerEvaluations = new IndexedDataTable<double>("Quality per Evaluations");
      var qpeRow = new IndexedDataRow<double>("First-hit Graph");
      qualityPerEvaluations.Rows.Add(qpeRow);
      double evaluations = GetEvaluatedSolutions();
      qpeRow.Values.Add(Tuple.Create((double)evaluations, (double)min));
      qpeRow.Values.Add(Tuple.Create((double)evaluations, (double)min));

      Results.Add(new Result("Nest with maximum T", new IntValue(worst.Index + 1)));
      Results.Add(new Result("Maximum T", new IntValue(min)));
      Results.Add(new Result("BestQuality", new DoubleValue(min)));
      Results.Add(new Result("Best Solution Found At", new TimeSpanValue(ExecutionTime)));
      Results.Add(new Result("Delta T", new PercentValue((min - Problem.BestKnownQuality) / Problem.BestKnownQuality)));
      Results.Add(new Result("Nest Results", algorithmsResults));
      Results.Add(new Result("QualityPerClock", qualityPerClock));
      Results.Add(new Result("QualityPerEvaluations", qualityPerEvaluations));

      base.Initialize(cancellationToken);
    }

    private double GetEvaluatedSolutions() {
      if (algorithmsResults == null) throw new InvalidOperationException("Strategy has not been started yet.");
      return algorithmsResults.Select(x => {
        IResult res;
        if (((ResultCollection)x.Value).TryGetValue(EvaluatedSolutionsName, out res)) {
          var itm = res.Value;
          if (itm is IntValue) return ((IntValue)itm).Value;
          else if (itm is DoubleValue) return ((DoubleValue)itm).Value;
        }
        throw new InvalidOperationException("No result " + EvaluatedSolutionsName + " in the collection of " + x.Name);
      }).Sum();
    }

    protected override void Run(CancellationToken cancellationToken) {
      var worst = qualities.Select((v, i) => new { Index = i, Quality = v }).MaxItems(x => x.Quality).First();
      var min = worst.Quality;

      while (ExecutionTime < MaximumRuntime) {
        algorithms[worst.Index].Start(cancellationToken);
        qualities[worst.Index] = (int)((DoubleValue)algorithms[worst.Index].Results["BestQuality"].Value).Value;
        worst = qualities.Select((v, i) => new { Index = i, Quality = v }).MaxItems(x => x.Quality).First();

        var evaluations = GetEvaluatedSolutions();
        var time = ExecutionTime.TotalSeconds;
        var qpcRow = qualityPerClock.Rows.First();
        var qpeRow = qualityPerEvaluations.Rows.First();
        qpcRow.Values[qpcRow.Values.Count - 1] = Tuple.Create(time, (double)min);
        qpeRow.Values[qpeRow.Values.Count - 1] = Tuple.Create(evaluations, (double)min);

        if (worst.Quality < min) {
          min = worst.Quality;
          ((IntValue)Results["Nest with maximum T"].Value).Value = worst.Index + 1;
          ((IntValue)Results["Maximum T"].Value).Value = min;
          ((DoubleValue)Results["BestQuality"].Value).Value = min;
          ((TimeSpanValue)Results["Best Solution Found At"].Value).Value = TimeSpan.FromSeconds(time);
          ((PercentValue)Results["Delta T"].Value).Value = (min - Problem.BestKnownQuality) / Problem.BestKnownQuality;
          qpcRow.Values.Add(Tuple.Create(time, (double)min));
          qpeRow.Values.Add(Tuple.Create(evaluations, (double)min));
        }

        if (cancellationToken.IsCancellationRequested) return;
      }
    }
  }
}