source: branches/OptimizationNetworks/HeuristicLab.Networks.IntegratedOptimization/3.3/TtpNetwork5.cs @ 14592

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Algorithms.CMAEvolutionStrategy;
using HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm;
using HeuristicLab.Algorithms.ParameterlessPopulationPyramid;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Core.Networks;
using HeuristicLab.Data;
using HeuristicLab.Encodings.PermutationEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Selection;

namespace HeuristicLab.Networks.IntegratedOptimization {
  [Item("TtpNetwork5", "An optimization network for the TTP.")]
  [Creatable("Optimization Networks")]
  [StorableClass]
  // standard ttp
  // cmaes variegates ksp values (factors)
  // 1) init cmaes (length = ksp.values.length)
  // 2) start cmaes
  // 3) evaluate vector as follows:
  // 4) change ksp values (mult by factor in vector)
  // 5) best ksp
  // 6) best tsp for ksp selection
  // 7) return ttp quality
  public sealed class TtpNetwork5 : Network, IOptimizer {
    #region Nodes
    public TtpOrchestratorNode5 Orchestrator {
      get { return (TtpOrchestratorNode5)Nodes["Orchestrator"]; }
    }

    public OrchestratedAlgorithmNode MetaSolver {
      get { return (OrchestratedAlgorithmNode)Nodes["MetaSolver"]; }
    }

    public OrchestratedAlgorithmNode TspSolver {
      get { return (OrchestratedAlgorithmNode)Nodes["TspSolver"]; }
    }

    public OrchestratedAlgorithmNode KspSolver {
      get { return (OrchestratedAlgorithmNode)Nodes["KspSolver"]; }
    }
    #endregion

    [StorableConstructor]
    private TtpNetwork5(bool deserializing) : base(deserializing) { }
    private TtpNetwork5(TtpNetwork5 original, Cloner cloner) : base(original, cloner) { }
    public TtpNetwork5() : base("TtpNetwork5") {
      var orchestratorNode = new TtpOrchestratorNode5("Orchestrator");
      Nodes.Add(orchestratorNode);

      var metaSolverNode = new OrchestratedAlgorithmNode("MetaSolver");
      var cmaes = new CMAEvolutionStrategy();
      cmaes.MaximumGenerations = 80;
      cmaes.Engine = new ParallelEngine.ParallelEngine();
      metaSolverNode.Algorithm = cmaes;
      orchestratorNode.MetaSolverOrchestrationPort.ConnectedPort = metaSolverNode.OrchestrationPort;
      Nodes.Add(metaSolverNode);

      var tspSolverNode = new OrchestratedAlgorithmNode("TspSolver") { CloneAlgorithm = true };
      var osga = new OffspringSelectionGeneticAlgorithm();
      osga.Problem = new TourProfitProblem();
      osga.ComparisonFactorLowerBound.Value = 1.0;
      osga.ComparisonFactorModifier = null;
      osga.ComparisonFactorUpperBound.Value = 1.0;
      var crossover = (MultiPermutationCrossover)(osga.Crossover = osga.CrossoverParameter.ValidValues.First(x => x is MultiPermutationCrossover));
      foreach (var c in crossover.Operators)
        crossover.Operators.SetItemCheckedState(c, c is CosaCrossover || c is OrderCrossover2 || c is PartiallyMatchedCrossover);
      osga.MaximumSelectionPressure.Value = 200;
      osga.Mutator = osga.MutatorParameter.ValidValues.First(x => x is MultiPermutationManipulator);
      osga.PopulationSize.Value = 200;
      osga.Selector = osga.SelectorParameter.ValidValues.First(x => x is RandomSelector);
      tspSolverNode.Algorithm = osga;
      orchestratorNode.TspSolverOrchestrationPort.ConnectedPort = tspSolverNode.OrchestrationPort;
      Nodes.Add(tspSolverNode);

      var kspSolverNode = new OrchestratedAlgorithmNode("KspSolver") { CloneAlgorithm = true };
      var p3 = new ParameterlessPopulationPyramid();
      p3.Problem = orchestratorNode.KspParameter.Value;
      p3.MaximumRuntime = 3;
      kspSolverNode.Algorithm = p3;
      orchestratorNode.KspSolverOrchestrationPort.ConnectedPort = kspSolverNode.OrchestrationPort;
      Nodes.Add(kspSolverNode);

      #region Import
      DoubleMatrix tspCoordinates;
      IntValue kspCapacity; IntArray kspItemWeights; IntArray kspItemValues;
      IntArray ttpAvailability; DoubleValue ttpMinSpeed; DoubleValue ttpMaxSpeed; DoubleValue ttpRentingRatio;
      TtpImporter.ImportTtpInstance(@"ttp-instances\berlin52-ttp\berlin52_n51_uncorr-similar-weights_05.ttp",
          out tspCoordinates,
          out kspCapacity, out kspItemValues, out kspItemWeights,
          out ttpAvailability, out ttpMinSpeed, out ttpMaxSpeed, out ttpRentingRatio);

      var tsp = orchestratorNode.TspParameter.Value;
      tsp.Coordinates = tspCoordinates;

      var ksp = orchestratorNode.KspParameter.Value;
      ksp.KnapsackCapacity = kspCapacity;
      ksp.Encoding.Length = kspItemValues.Length;
      ksp.Values = kspItemValues;
      ksp.Weights = kspItemWeights;

      orchestratorNode.AvailabilityParameter.Value = ttpAvailability;
      orchestratorNode.MinSpeedParameter.Value = ttpMinSpeed;
      orchestratorNode.MaxSpeedParameter.Value = ttpMaxSpeed;
      orchestratorNode.RentingRatioParameter.Value = ttpRentingRatio;
      #endregion
    }

    public event EventHandler ExecutionStateChanged;
    public event EventHandler ExecutionTimeChanged;
    public event EventHandler Prepared;
    public event EventHandler Started;
    public event EventHandler Paused;
    public event EventHandler Stopped;
    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;

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

    #region IOptimizer Members
    public RunCollection Runs { get { return MetaSolver.Algorithm.Runs; } }

    public IEnumerable<IOptimizer> NestedOptimizers { get { yield break; } }

    public ExecutionState ExecutionState { get { return MetaSolver.Algorithm.ExecutionState; } }

    public TimeSpan ExecutionTime { get { return MetaSolver.Algorithm.ExecutionTime; } }

    public void Prepare(bool clearRuns) { MetaSolver.Algorithm.Prepare(clearRuns); }

    public void Prepare() { Orchestrator.Prepare(); }

    public void Start() { Orchestrator.Start(); }

    public void Pause() { Orchestrator.Stop(); }

    public void Stop() { Orchestrator.Stop(); }
    #endregion
  }
}