#region License Information
/* HeuristicLab
* Copyright (C) 2002-2010 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 .
*/
#endregion
using System;
using System.Drawing;
using System.Linq;
using HeuristicLab.Collections;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
namespace HeuristicLab.Optimization {
///
/// An experiment which contains multiple batch runs of algorithms.
///
[Item("Experiment", "An experiment which contains multiple batch runs of algorithms.")]
[Creatable("Testing & Analysis")]
[StorableClass]
public sealed class Experiment : NamedItem, IOptimizer, IStorableContent {
public string Filename { get; set; }
public override Image ItemImage {
get {
if (ExecutionState == ExecutionState.Prepared) return HeuristicLab.Common.Resources.VS2008ImageLibrary.ExecutablePrepared;
else if (ExecutionState == ExecutionState.Started) return HeuristicLab.Common.Resources.VS2008ImageLibrary.ExecutableStarted;
else if (ExecutionState == ExecutionState.Paused) return HeuristicLab.Common.Resources.VS2008ImageLibrary.ExecutablePaused;
else if (ExecutionState == ExecutionState.Stopped) return HeuristicLab.Common.Resources.VS2008ImageLibrary.ExecutableStopped;
else return HeuristicLab.Common.Resources.VS2008ImageLibrary.Event;
}
}
[Storable]
private ExecutionState executionState;
public ExecutionState ExecutionState {
get { return executionState; }
private set {
if (executionState != value) {
executionState = value;
OnExecutionStateChanged();
OnItemImageChanged();
}
}
}
[Storable]
private TimeSpan executionTime;
public TimeSpan ExecutionTime {
get { return executionTime; }
private set {
executionTime = value;
OnExecutionTimeChanged();
}
}
[Storable]
private OptimizerList optimizers;
public OptimizerList Optimizers {
get { return optimizers; }
}
[Storable]
private RunCollection runs;
public RunCollection Runs {
get { return runs; }
private set {
if (value == null) throw new ArgumentNullException();
if (runs != value) {
if (runs != null) DeregisterRunsEvents();
runs = value;
if (runs != null) RegisterRunsEvents();
}
}
}
private bool stopPending;
public Experiment()
: base() {
name = ItemName;
description = ItemDescription;
executionState = ExecutionState.Stopped;
executionTime = TimeSpan.Zero;
optimizers = new OptimizerList();
Runs = new RunCollection();
stopPending = false;
Initialize();
}
public Experiment(string name)
: base(name) {
description = ItemDescription;
executionState = ExecutionState.Stopped;
executionTime = TimeSpan.Zero;
optimizers = new OptimizerList();
Runs = new RunCollection();
stopPending = false;
Initialize();
}
public Experiment(string name, string description)
: base(name, description) {
executionState = ExecutionState.Stopped;
executionTime = TimeSpan.Zero;
optimizers = new OptimizerList();
Runs = new RunCollection();
stopPending = false;
Initialize();
}
[StorableConstructor]
private Experiment(bool deserializing)
: base(deserializing) {
stopPending = false;
}
[StorableHook(HookType.AfterDeserialization)]
private void AfterDeserialization() {
Initialize();
}
private Experiment(Experiment original, Cloner cloner)
: base(original, cloner) {
executionState = original.executionState;
executionTime = original.executionTime;
optimizers = cloner.Clone(original.optimizers);
runs = cloner.Clone(original.runs);
stopPending = original.stopPending;
Initialize();
}
public override IDeepCloneable Clone(Cloner cloner) {
if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
return new Experiment(this, cloner);
}
private void Initialize() {
RegisterOptimizersEvents();
foreach (IOptimizer optimizer in optimizers)
RegisterOptimizerEvents(optimizer);
if (runs != null) RegisterRunsEvents();
}
public void Prepare() {
Prepare(false);
}
public void Prepare(bool clearRuns) {
if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused) && (ExecutionState != ExecutionState.Stopped))
throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
if (Optimizers.Count > 0) {
if (clearRuns) runs.Clear();
foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState != ExecutionState.Started))
optimizer.Prepare(clearRuns);
}
}
public void Start() {
if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
stopPending = false;
if (Optimizers.Count > 0) {
IOptimizer optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused));
if (optimizer != null) optimizer.Start();
}
}
public void Pause() {
if (ExecutionState != ExecutionState.Started)
throw new InvalidOperationException(string.Format("Pause not allowed in execution state \"{0}\".", ExecutionState));
if (Optimizers.Count > 0) {
foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState == ExecutionState.Started))
optimizer.Pause();
}
}
public void Stop() {
if ((ExecutionState != ExecutionState.Started) && (ExecutionState != ExecutionState.Paused))
throw new InvalidOperationException(string.Format("Stop not allowed in execution state \"{0}\".", ExecutionState));
stopPending = true;
if (Optimizers.Count > 0) {
foreach (IOptimizer optimizer in Optimizers.Where(x => (x.ExecutionState == ExecutionState.Started) || (x.ExecutionState == ExecutionState.Paused)))
optimizer.Stop();
}
}
#region Events
public event EventHandler ExecutionStateChanged;
private void OnExecutionStateChanged() {
EventHandler handler = ExecutionStateChanged;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler ExecutionTimeChanged;
private void OnExecutionTimeChanged() {
EventHandler handler = ExecutionTimeChanged;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler Prepared;
private void OnPrepared() {
ExecutionState = ExecutionState.Prepared;
EventHandler handler = Prepared;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler Started;
private void OnStarted() {
ExecutionState = ExecutionState.Started;
EventHandler handler = Started;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler Paused;
private void OnPaused() {
ExecutionState = ExecutionState.Paused;
EventHandler handler = Paused;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler Stopped;
private void OnStopped() {
ExecutionState = ExecutionState.Stopped;
EventHandler handler = Stopped;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler> ExceptionOccurred;
private void OnExceptionOccurred(Exception exception) {
EventHandler> handler = ExceptionOccurred;
if (handler != null) handler(this, new EventArgs(exception));
}
private void RegisterOptimizersEvents() {
Optimizers.CollectionReset += new CollectionItemsChangedEventHandler>(Optimizers_CollectionReset);
Optimizers.ItemsAdded += new CollectionItemsChangedEventHandler>(Optimizers_ItemsAdded);
Optimizers.ItemsRemoved += new CollectionItemsChangedEventHandler>(Optimizers_ItemsRemoved);
Optimizers.ItemsReplaced += new CollectionItemsChangedEventHandler>(Optimizers_ItemsReplaced);
}
private void DeregisterOptimizersEvents() {
Optimizers.CollectionReset -= new CollectionItemsChangedEventHandler>(Optimizers_CollectionReset);
Optimizers.ItemsAdded -= new CollectionItemsChangedEventHandler>(Optimizers_ItemsAdded);
Optimizers.ItemsRemoved -= new CollectionItemsChangedEventHandler>(Optimizers_ItemsRemoved);
Optimizers.ItemsReplaced -= new CollectionItemsChangedEventHandler>(Optimizers_ItemsReplaced);
}
private void Optimizers_CollectionReset(object sender, CollectionItemsChangedEventArgs> e) {
foreach (IndexedItem item in e.OldItems)
RemoveOptimizer(item.Value);
foreach (IndexedItem item in e.Items)
AddOptimizer(item.Value);
}
private void Optimizers_ItemsAdded(object sender, CollectionItemsChangedEventArgs> e) {
foreach (IndexedItem item in e.Items)
AddOptimizer(item.Value);
}
private void Optimizers_ItemsRemoved(object sender, CollectionItemsChangedEventArgs> e) {
foreach (IndexedItem item in e.Items)
RemoveOptimizer(item.Value);
}
private void Optimizers_ItemsReplaced(object sender, CollectionItemsChangedEventArgs> e) {
foreach (IndexedItem item in e.OldItems)
RemoveOptimizer(item.Value);
foreach (IndexedItem item in e.Items)
AddOptimizer(item.Value);
}
private void AddOptimizer(IOptimizer optimizer) {
RegisterOptimizerEvents(optimizer);
Runs.AddRange(optimizer.Runs);
optimizer.Prepare();
if (ExecutionState == ExecutionState.Stopped && optimizer.ExecutionState == ExecutionState.Prepared)
OnPrepared();
}
private void RemoveOptimizer(IOptimizer optimizer) {
DeregisterOptimizerEvents(optimizer);
Runs.RemoveRange(optimizer.Runs);
if (ExecutionState == ExecutionState.Prepared && !optimizers.Any(opt => opt.ExecutionState == ExecutionState.Prepared))
OnStopped();
}
private void RegisterOptimizerEvents(IOptimizer optimizer) {
optimizer.ExceptionOccurred += new EventHandler>(optimizer_ExceptionOccurred);
optimizer.ExecutionTimeChanged += new EventHandler(optimizer_ExecutionTimeChanged);
optimizer.Paused += new EventHandler(optimizer_Paused);
optimizer.Prepared += new EventHandler(optimizer_Prepared);
optimizer.Started += new EventHandler(optimizer_Started);
optimizer.Stopped += new EventHandler(optimizer_Stopped);
optimizer.Runs.CollectionReset += new CollectionItemsChangedEventHandler(optimizer_Runs_CollectionReset);
optimizer.Runs.ItemsAdded += new CollectionItemsChangedEventHandler(optimizer_Runs_ItemsAdded);
optimizer.Runs.ItemsRemoved += new CollectionItemsChangedEventHandler(optimizer_Runs_ItemsRemoved);
}
private void DeregisterOptimizerEvents(IOptimizer optimizer) {
optimizer.ExceptionOccurred -= new EventHandler>(optimizer_ExceptionOccurred);
optimizer.ExecutionTimeChanged -= new EventHandler(optimizer_ExecutionTimeChanged);
optimizer.Paused -= new EventHandler(optimizer_Paused);
optimizer.Prepared -= new EventHandler(optimizer_Prepared);
optimizer.Started -= new EventHandler(optimizer_Started);
optimizer.Stopped -= new EventHandler(optimizer_Stopped);
optimizer.Runs.CollectionReset -= new CollectionItemsChangedEventHandler(optimizer_Runs_CollectionReset);
optimizer.Runs.ItemsAdded -= new CollectionItemsChangedEventHandler(optimizer_Runs_ItemsAdded);
optimizer.Runs.ItemsRemoved -= new CollectionItemsChangedEventHandler(optimizer_Runs_ItemsRemoved);
}
private void optimizer_ExceptionOccurred(object sender, EventArgs e) {
OnExceptionOccurred(e.Value);
}
private void optimizer_ExecutionTimeChanged(object sender, EventArgs e) {
ExecutionTime = Optimizers.Aggregate(TimeSpan.Zero, (t, o) => t + o.ExecutionTime);
}
private void optimizer_Paused(object sender, EventArgs e) {
if (Optimizers.All(x => x.ExecutionState != ExecutionState.Started))
OnPaused();
}
private void optimizer_Prepared(object sender, EventArgs e) {
if (ExecutionState == ExecutionState.Stopped)
OnPrepared();
}
private void optimizer_Started(object sender, EventArgs e) {
if (ExecutionState != ExecutionState.Started)
OnStarted();
}
private void optimizer_Stopped(object sender, EventArgs e) {
if (!stopPending && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) {
Optimizers.First(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)).Start();
} else {
if (Optimizers.All(x => (x.ExecutionState != ExecutionState.Started) && (x.ExecutionState != ExecutionState.Paused))) {
stopPending = false;
OnStopped();
}
}
}
private void optimizer_Runs_CollectionReset(object sender, CollectionItemsChangedEventArgs e) {
Runs.RemoveRange(e.OldItems);
Runs.AddRange(e.Items);
}
private void optimizer_Runs_ItemsAdded(object sender, CollectionItemsChangedEventArgs e) {
Runs.AddRange(e.Items);
}
private void optimizer_Runs_ItemsRemoved(object sender, CollectionItemsChangedEventArgs e) {
Runs.RemoveRange(e.Items);
}
private void RegisterRunsEvents() {
runs.CollectionReset += new CollectionItemsChangedEventHandler(Runs_CollectionReset);
runs.ItemsRemoved += new CollectionItemsChangedEventHandler(Runs_ItemsRemoved);
}
private void DeregisterRunsEvents() {
runs.CollectionReset -= new CollectionItemsChangedEventHandler(Runs_CollectionReset);
runs.ItemsRemoved -= new CollectionItemsChangedEventHandler(Runs_ItemsRemoved);
}
private void Runs_CollectionReset(object sender, CollectionItemsChangedEventArgs e) {
foreach (IOptimizer optimizer in Optimizers)
optimizer.Runs.RemoveRange(e.OldItems);
}
private void Runs_ItemsRemoved(object sender, CollectionItemsChangedEventArgs e) {
foreach (IOptimizer optimizer in Optimizers)
optimizer.Runs.RemoveRange(e.Items);
}
#endregion
}
}