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

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.BinaryVectorEncoding;
using HeuristicLab.Encodings.PermutationEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.Instances;

namespace HeuristicLab.Problems.Scheduling.CFSAP {
  [Item("Cyclic flow shop with two machines and multiple nests (multi-CFSAP)", "Non-permutational cyclic flow shop scheduling problem with multiple nests of two machines each from W. Bozejko.")]
  [Creatable(CreatableAttribute.Categories.CombinatorialProblems)]
  [StorableClass]
  public class MultiNestCFSAP : SingleObjectiveBasicProblem<MultiEncoding>, IProblemInstanceConsumer<CFSAPData> {
    public override bool Maximization { get { return false; } }

    public IValueParameter<ItemList<IntMatrix>> ProcessingTimesParameter {
      get { return (IValueParameter<ItemList<IntMatrix>>)Parameters["ProcessingTimes"]; }
    }

    public ItemList<IntMatrix> ProcessingTimes {
      get { return ProcessingTimesParameter.Value; }
      set { ProcessingTimesParameter.Value = value; }
    }

    public IValueParameter<ItemList<ItemList<IntMatrix>>> SetupTimesParameter {
      get { return (IValueParameter<ItemList<ItemList<IntMatrix>>>)Parameters["SetupTimes"]; }
    }

    public ItemList<ItemList<IntMatrix>> SetupTimes {
      get { return SetupTimesParameter.Value; }
      set { SetupTimesParameter.Value = value; }
    }

    [StorableConstructor]
    protected MultiNestCFSAP(bool deserializing) : base(deserializing) { }
    protected MultiNestCFSAP(MultiNestCFSAP original, Cloner cloner)
      : base(original, cloner) { }
    public MultiNestCFSAP() {
      Parameters.Add(new ValueParameter<ItemList<IntMatrix>>("ProcessingTimes", "The processing times of each nest, each machine, each job.") { GetsCollected = false });
      Parameters.Add(new ValueParameter<ItemList<ItemList<IntMatrix>>>("SetupTimes", "The sequence dependent set up times for each nest, each machine, and each job to each other.") { GetsCollected = false });

      ProcessingTimesParameter.Value = new ItemList<IntMatrix>() {
        new IntMatrix(new int[,] {
          { 5, 4, 3, 2, 1 },
          { 1, 2, 3, 4, 5 }
        })
      };

      SetupTimesParameter.Value = new ItemList<ItemList<IntMatrix>>() { new ItemList<IntMatrix>() };
      SetupTimesParameter.Value[0].Add(new IntMatrix(new int[,] {
        { 3, 4, 5, 4, 3 },
        { 3, 4, 5, 4, 3 },
        { 3, 4, 5, 4, 3 },
        { 3, 4, 5, 4, 3 },
        { 3, 4, 5, 4, 3 },
      }));
      SetupTimesParameter.Value[0].Add(new IntMatrix(new int[,] {
        { 5, 4, 3, 4, 5 },
        { 5, 4, 3, 4, 5 },
        { 5, 4, 3, 4, 5 },
        { 5, 4, 3, 4, 5 },
        { 5, 4, 3, 4, 5 },
      }));

      Encoding.Add(new PermutationEncoding("seq0", 5, PermutationTypes.RelativeDirected));
      Encoding.Add(new BinaryVectorEncoding("assign0", 5));

      EncodingParameter.GetsCollected = false;
      foreach (var param in ((IEncoding)Encoding).Parameters.OfType<IValueParameter>().ToList()) {
        param.GetsCollected = false;
      }

      Operators.RemoveAll(x => x is SingleObjectiveMoveGenerator);
      Operators.RemoveAll(x => x is SingleObjectiveMoveEvaluator);
      Operators.RemoveAll(x => x is SingleObjectiveMoveMaker);
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new MultiNestCFSAP(this, cloner);
    }

    public override double Evaluate(Individual individual, IRandom random) {
      var nests = ProcessingTimesParameter.Value.Count;
      var maxT = int.MinValue;
      for (var i = 0; i < nests; i++) {
        var order = individual.Permutation("seq" + i);
        var assignment = individual.BinaryVector("assign" + i);
        int T = CFSAP.EvaluateAssignement(order, assignment.Select(x => x ? 1 : 0).ToArray(),
          ProcessingTimesParameter.Value[i], SetupTimesParameter.Value[i]);
        if (T > maxT) maxT = T;
      }
      return maxT;
    }

    /// <summary>
    /// Imports the all nests given in the CFSAPData.
    /// </summary>
    /// <param name="data">The data of all nests.</param>
    public void Load(CFSAPData data) {
      if (data.Machines.Any(x => x != 2)) throw new ArgumentException("Currently only two machines per nest are supported.");
      ProcessingTimesParameter.Value = new ItemList<IntMatrix>();
      for (var n = 0; n < data.Nests; n++) {
        var pr = new int[data.Machines[n], data.Jobs];
        for (var i = 0; i < data.Machines[n]; i++)
          for (var j = 0; j < data.Jobs; j++)
            pr[i, j] = data.ProcessingTimes[n][i][j];
        ProcessingTimesParameter.Value.Add(new IntMatrix(pr));
      }
      SetupTimesParameter.Value = new ItemList<ItemList<IntMatrix>>();
      for (var n = 0; n < data.Nests; n++) {
        var setups = new ItemList<IntMatrix>(data.Machines[n]);
        for (var m = 0; m < data.SetupTimes[n].GetLength(0); m++) {
          var setupTimes = new int[data.Jobs, data.Jobs];
          for (var i = 0; i < data.Jobs; i++)
            for (var j = 0; j < data.Jobs; j++)
              setupTimes[i, j] = data.SetupTimes[n][m][i][j];
          setups.Add(new IntMatrix(setupTimes));
        }
        SetupTimesParameter.Value.Add(setups);
      }
      foreach (var enc in Encoding.Encodings.ToList())
        Encoding.Remove(enc);
      for (var n = 0; n < data.Nests; n++) {
        Encoding.Add(new PermutationEncoding("seq" + n, data.Jobs, PermutationTypes.RelativeDirected));
        Encoding.Add(new BinaryVectorEncoding("assign" + n, data.Jobs));
      }

      #region Reduce run size by removing collected parameters
      foreach (var param in ((IEncoding)Encoding).Parameters.OfType<IValueParameter>().ToList())
        param.GetsCollected = false;

      var solCreator = SolutionCreator as IParameterizedItem;
      if (solCreator != null) {
        foreach (var param in solCreator.Parameters.OfType<IValueParameter>().ToList()) {
          param.GetsCollected = false;
          var secondLevel = param.Value as IParameterizedItem;
          if (secondLevel != null) {
            foreach (var secondLevelParam in secondLevel.Parameters.OfType<IValueParameter>().ToList())
              secondLevelParam.GetsCollected = false;
          }
        }
      }
      #endregion

      Name = data.Name;
      Description = data.Description;
      if (data.BestKnownCycleTime.HasValue)
        BestKnownQuality = data.BestKnownCycleTime.Value;
      else BestKnownQualityParameter.Value = null;
    }
  }
}