source: branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem.cs @ 6219

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2011 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.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Core;
using HeuristicLab.Optimization;
using HeuristicLab.Common;
using System.Drawing;
using HeuristicLab.Data;
using System.IO;
using HeuristicLab.Problems.Scheduling.Encodings;
using HeuristicLab.Problems.Scheduling.Evaluators;
using HeuristicLab.Parameters;
using HeuristicLab.Problems.Scheduling.Encodings.JobSequenceMatrix;
using HeuristicLab.Encodings.PermutationEncoding;
using HeuristicLab.Problems.Scheduling.Analyzers;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.Problems.Scheduling.Encodings.JobSequenceMatrix.Manipulators;
using HeuristicLab.Problems.Scheduling.Encodings.JobSequenceMatrix.Crossovers;
using HeuristicLab.Problems.Scheduling.Interfaces;
using HeuristicLab.Problems.Scheduling.Encodings.PriorityRulesVector;
using HeuristicLab.Encodings.IntegerVectorEncoding;

namespace HeuristicLab.Problems.Scheduling {
  [Item("JobShop Scheduling Problem", "Represents a standard JobShop Scheduling Problem")]
  [Creatable("Problems")]
  [StorableClass]
  public sealed class JobShopSchedulingProblem : SchedulingProblem {
    [StorableConstructor]
    private JobShopSchedulingProblem(bool deserializing) : base(deserializing) { }
    private JobShopSchedulingProblem(JobShopSchedulingProblem original, Cloner cloner)
      : base(original, cloner) {
        operators = original.operators.Select(x => (IOperator)cloner.Clone(x)).ToList();
        this.encodingType = original.encodingType;
        AttachEventHandlers();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new JobShopSchedulingProblem(this, cloner);
    }


    #region Parameter Properties
    public ValueParameter<ItemList<JSSPJob>> JobsParameter {
      get { return (ValueParameter<ItemList<JSSPJob>>)Parameters["Jobs"]; }
    }
    public OptionalValueParameter<Schedule> BestKnownSolutionParameter {
      get { return (OptionalValueParameter<Schedule>)Parameters["BestKnownSolution"]; }
    }
    #endregion

    #region Properties
    public ItemList<JSSPJob> Jobs {
      get { return JobsParameter.Value; }
      set { JobsParameter.Value = value; }
    }
    public Schedule BestKnownSolution {
      get { return BestKnownSolutionParameter.Value; }
      set { BestKnownSolutionParameter.Value = value; }
    }
    #endregion


    [Storable]
    private List<IOperator> operators;

    [Storable]
    private JSSPEncodingTypes encodingType;

    public JobShopSchedulingProblem()
      : base(new SchedulingEvaluator (), new JSMRandomCreator ()) {
        Parameters.Add(new ValueParameter<ItemList<JSSPJob>>("Jobs", "Jobdata defining the precedence relationships and the duration of the tasks in this JSSP-Instance.", new ItemList<JSSPJob>()));
        Parameters.Add(new OptionalValueParameter<Schedule>("BestKnownSolution", "The best known solution of this JSSP instance.")); 
        encodingType = JSSPEncodingTypes.JSMEncoding;
        InitializeOperators();
        AttachEventHandlers();
    }

    #region Events
    //TODO: Implement event handlers for problem specific events!
    protected override void OnSolutionCreatorChanged() {
      if (SolutionCreator.GetType().Equals(typeof(JSMRandomCreator)))
        encodingType = JSSPEncodingTypes.JSMEncoding;
      else
        encodingType = JSSPEncodingTypes.PRVEncoding;

      InitializeOperators();
    }
    #endregion

    #region Helpers
    private void InitializeOperators() {
      Operators.Clear();
      ApplyEncoding();
      Operators.Add(new BestSchedulingSolutionAnalyzer());
      //ParameterizeAnalyzer();
      //ParameterizeOperators();
    }

    private void ApplyEncoding() {
      if (encodingType == JSSPEncodingTypes.JSMEncoding) {
        Operators.AddRange(ApplicationManager.Manager.GetInstances<IJSMOperator>());
        ((SchedulingEvaluator)this.EvaluatorParameter.ActualValue).InitializeOperatorGraph<JSMEncoding>(new JSMDecoder(), new MakespanEvaluator());
      } else {
        if (encodingType == JSSPEncodingTypes.PRVEncoding) {
          Operators.AddRange(ApplicationManager.Manager.GetInstances<IPRVOperator>());
          ((SchedulingEvaluator)this.EvaluatorParameter.ActualValue).InitializeOperatorGraph<PRVEncoding>(new PRVDecoder(), new MakespanEvaluator());
        }
      }
    }

    private void AttachEventHandlers() {
      //TODO: Attach event handlers implemented aabove to appropriate events of the problem.
    }

    private void ParameterizeOperators() {
      throw new NotImplementedException();
    }

    private void ParameterizeAnalyzer() {
      throw new NotImplementedException();
    }
    #endregion

    #region Importmethods
    private List<string> SplitString(string line) {
      List<string> data = new List<string>(line.Split(' '));
      List<string> result = new List<string>();

      foreach (string s in data) {
        if (!String.IsNullOrEmpty(s) && s != "" && s != " ")
          result.Add(s);
      }

      return result;
    }
    public void ImportFromORLibrary(string fileName) {
      if (!File.Exists(fileName))
        return;
      StreamReader problemFile = new StreamReader(fileName);
      //assures that the parser only reads the first problem instance given in the file
      bool problemFound = false;

      Jobs = new ItemList<JSSPJob>();

      while (!problemFile.EndOfStream && !problemFound) {
        string line = problemFile.ReadLine();
        List<string> data = SplitString(line);
        if (data.Count > 0 && ((int)data[0][0] >= 48 && (int)data[0][0] <= 57)) {
          int jobCount = 0;
          //data[0] = nrOfJobs
          //data[1] = nrOfResources
          if (data.Count > 2)
            BestKnownQualityParameter.ActualValue = new DoubleValue(Double.Parse (data[2]));
          line = problemFile.ReadLine();
          data = SplitString(line);
          while (!problemFile.EndOfStream && data.Count > 0 && ((int)data[0][0] >= 48 && (int)data[0][0] <= 57)) {
            JSSPJob j = new JSSPJob(new IntValue(jobCount));
            for (int i = 0; i < data.Count; i++) {
              JSSPTask t = new JSSPTask(new IntValue (i / 2), new IntValue(Int32.Parse(data[i])), new DoubleValue(Double.Parse(data[i + 1])), j);
              if (j.Tasks.Count > 0) {
                t.PreviousTask = j.Tasks[j.Tasks.Count - 1];
                j.Tasks[j.Tasks.Count - 1].NextTask = t;
                t.StartTime = new DoubleValue (t.PreviousTask.EndTime.Value + 2);
              }
              j.Tasks.Add(t);
              i++;
            }//for
            this.Jobs.Add(j);
            jobCount++;
            line = problemFile.ReadLine();
            data = SplitString(line);
          }//while
          problemFound = true;
        }//if
      }//while
      problemFile.Close();
    }
    #endregion

  }
}