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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
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 TimeSpan MaximumRuntime {
      get { return MaximumRuntimeParameter.Value.Value; }
      set { MaximumRuntimeParameter.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);
    }
    public MultiNestCFSAPSolvingStrategy() {
      Parameters.Add(new ValueParameter<IAlgorithm>("Solver", "The actual solver template."));
      Parameters.Add(new FixedValueParameter<TimeSpanValue>("MaximumRuntime", "The maximum time that the strategy should run.", new TimeSpanValue(TimeSpan.FromSeconds(60))));
    }
    
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MultiNestCFSAPSolvingStrategy(this, cloner);
    }

    [Storable]
    private List<IAlgorithm> algorithms;
    [Storable]
    private int[] qualities;
    [Storable]
    private ResultCollection algorithmsResults;

    protected override void OnPrepared() {
      base.OnPrepared();
      algorithms = null;
      qualities = 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;

      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("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));

      base.Initialize(cancellationToken);
    }

    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();
        if (worst.Quality < min) {
          min = worst.Quality;
          Results["Nest with maximum T"].Value = new IntValue(worst.Index + 1);
          Results["Maximum T"].Value = new IntValue(min);
          Results["Best Solution Found At"].Value = new TimeSpanValue(ExecutionTime);
          Results["Delta T"].Value = new PercentValue((min - Problem.BestKnownQuality) / Problem.BestKnownQuality);
        }
        if (cancellationToken.IsCancellationRequested) return;
      }
    }
  }
}