source: branches/DynamicVehicleRouting/HeuristicLab.PDPSimulation/3.3/Operators/PriorityDispatchingMetaOptEvaluator.cs @ 11767

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Data;
using HeuristicLab.Common;
using System.Threading;
using System.Threading.Tasks;
using HeuristicLab.Encodings.PermutationEncoding;
using HeuristicLab.Encodings.RealVectorEncoding;
using System.Diagnostics;

namespace HeuristicLab.PDPSimulation.Operators {
  [Item("PriorityDispatchingMetaOptEvaluator", "Metaoptimization of the priority dispatching parameters for the PDP simulation.")]
  [StorableClass]
  public abstract class PriorityDispatchingMetaOptEvaluator : SingleSuccessorOperator, ISingleObjectiveEvaluator {
    public ILookupParameter<DoubleValue> QualityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
    }

    public IValueParameter<ItemList<PickupDeliverySimulation>> SimulationParameter {
      get { return (IValueParameter<ItemList<PickupDeliverySimulation>>)Parameters["Simulation"]; }
    }

    public IValueParameter<IntValue> RepetitionsParameter {
      get { return (IValueParameter<IntValue>)Parameters["Repetitions"]; }
    }

    public PriorityDispatchingMetaOptEvaluator() {
      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "Result of the evaluation of a solution."));
      Parameters.Add(new ValueParameter<ItemList<PickupDeliverySimulation>>("Simulation", "The PDP simulation"));
      Parameters.Add(new ValueParameter<IntValue>("Repetitions", "The number of repetitions", new IntValue(1)));
    }

    [StorableConstructor]
    protected PriorityDispatchingMetaOptEvaluator(bool deserializing) : base(deserializing) { }
    protected PriorityDispatchingMetaOptEvaluator(PriorityDispatchingMetaOptEvaluator original, Cloner cloner) : base(original, cloner) { }

    protected abstract void Parameterize(PriorityDispatching dispatching);

    public override IOperation Apply() {
      double quality = 0;

      List<PickupDeliverySimulation> simulations = new List<PickupDeliverySimulation>();
      foreach (var originalSimulation in SimulationParameter.Value) {
        PickupDeliverySimulation simulation = originalSimulation.Clone() as PickupDeliverySimulation;
        PriorityDispatching dispatching = simulation.OptimizationParameter.Value as PriorityDispatching;
        Parameterize(dispatching);

        simulations.Add(simulation);
      }

      int repetitions = 0;
      object locker = new object();
      var options = new ParallelOptions();
      //options.MaxDegreeOfParallelism = Math.Max(Environment.ProcessorCount - 1, 1);
      Parallel.ForEach<PickupDeliverySimulation>(simulations, options, simulation => {
        int index = simulations.IndexOf(simulation);
        int executions = 0;

        using (EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset)) {
          EventHandler handler = new EventHandler(delegate(object o, EventArgs e) {
            waitHandle.Set();
          });

          while (executions < RepetitionsParameter.Value.Value) {
            waitHandle.Reset();

            simulation.Prepared += handler;
            simulation.Prepare(true);
            waitHandle.WaitOne();
            simulation.Prepared -= handler;

            waitHandle.Reset();

            simulation.Stopped += handler;
            simulation.Start();
            waitHandle.WaitOne();
            simulation.Stopped -= handler;

            if (!simulation.Results.ContainsKey("Finished")) {
              throw new Exception("Simulation did not finish");
            }
            executions++;

            double leadTime = (simulation.Results["LeadTime"].Value as DoubleValue).Value;
            double tardiness = (simulation.Results["TotalTardinessPenalty"].Value as DoubleValue).Value;

            lock (locker) {
              double runQuality = leadTime + tardiness;

              quality += runQuality;
              repetitions++;
            }
          }
        }
      });

      QualityParameter.ActualValue = new DoubleValue(quality / (double)repetitions);

      return base.Apply();
    }
  }
}