source: branches/SimulationCore/HeuristicLab.SimulationCore/3.3/DiscreteEvent/DiscreteEventSimulation.cs @ 10717

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

namespace HeuristicLab.SimulationCore {
  [StorableClass]
  public abstract class DiscreteEventSimulation<TModel> : Simulation, IDiscreteEventSimulation<TModel> where TModel : class, IModel {
    [Storable]
    public IAction<TModel> InitialAction { get; protected set; }
    [Storable]
    public IEnumerable<IActivity<TModel>> Activities { get; protected set; }
    [Storable]
    public IEnumerable<IReporter<TModel>> Reporters { get; protected set; }
    [Storable]
    public TModel Model { get; protected set; }

    protected CompositeEventQueue<TModel> CompositeEventQueue { get; private set; }

    protected IFixedValueParameter<DoubleValue> MaximumTimeParameter {
      get { return (IFixedValueParameter<DoubleValue>)Parameters["MaximumTime"]; }
    }

    public double MaximumTime {
      get { return MaximumTimeParameter.Value.Value; }
      set { MaximumTimeParameter.Value.Value = value; }
    }

    [StorableConstructor]
    protected DiscreteEventSimulation(bool deserializing) : base(deserializing) { }
    protected DiscreteEventSimulation(DiscreteEventSimulation<TModel> original, Cloner cloner)
      : base(original, cloner) {
      InitialAction = cloner.Clone(original.InitialAction);
      Activities = original.Activities.Select(cloner.Clone).ToList();
      Reporters = original.Reporters.Select(cloner.Clone).ToList();
      Model = cloner.Clone(original.Model);
    }
    protected DiscreteEventSimulation() {
      Parameters.Add(new FixedValueParameter<DoubleValue>("MaximumTime", "The simulation stops after reaching this time.", new DoubleValue(1000)));
    }

    protected override void OnPrepared() {
      base.OnPrepared();
      if (CompositeEventQueue != null)
        CompositeEventQueue.Clear();
    }

    protected override void Run(CancellationToken cancellationToken) {
      CompositeEventQueue = new CompositeEventQueue<TModel>(Activities.Select(x => x.EventQueue));

      var log = new StringBuilder();

      var actionMonitor = new Dictionary<Type, List<IActivity<TModel>>>();
      foreach (var activity in Activities) {
        foreach (var actionId in activity.MonitoredActions) {
          if (!actionMonitor.ContainsKey(actionId)) actionMonitor[actionId] = new List<IActivity<TModel>>();
          actionMonitor[actionId].Add(activity);
        }
      }

      if (CompositeEventQueue.Empty && InitialAction != null) {
        InitialAction.Execute(Model);
        CallActivities(actionMonitor, InitialAction);
      }

      while (!CompositeEventQueue.Empty && Model.CurrentTime < MaximumTime) {
        var @event = CompositeEventQueue.Pop();
        if (@event.Time < Model.CurrentTime) continue;
        log.AppendLine(@event.Action.GetType().Name);
        Model.CurrentTime = @event.Time;

        var nextEvent = CompositeEventQueue.Empty ? null : CompositeEventQueue.Peek();
        var action = @event.Action;

        action.Execute(Model);

        if (nextEvent == null || @event.Time < nextEvent.Time) {
          foreach (var reporter in Reporters)
            reporter.UpdateReporting(Model, Results);
        }

        CallActivities(actionMonitor, action);

        cancellationToken.ThrowIfCancellationRequested();
      };
    }

    private void CallActivities(Dictionary<Type, List<IActivity<TModel>>> actionMonitor, IAction<TModel> action) {
      if (actionMonitor.ContainsKey(action.GetType())) {
        foreach (var activity in actionMonitor[action.GetType()])
          activity.ManageEvents(Model, action);
      }

      if (actionMonitor.ContainsKey(typeof(object))) {
        foreach (var activity in actionMonitor[typeof(object)])
          activity.ManageEvents(Model, action);
      }
    }
  }
}