source: branches/PushGP/HeuristicLab.PushGP/Push.Thesis/RunGrouper.cs @ 15345

using System.Linq;

namespace Push.Thesis {
  using System;
  using System.Collections.Generic;
  using System.Globalization;
  using System.IO;
  using System.Threading.Tasks;

  using HeuristicLab.Common;
  using HeuristicLab.Data;
  using HeuristicLab.Optimization;
  using HeuristicLab.Persistence.Default.Xml;

  public class JobResult {
    public bool IsWithOffspringSelection { get; set; }
    public string Name { get; set; }
    public double Best { get; set; }
    public double AverageBest { get; set; }
    public double StandardDeviation { get; set; }
    public int SolvedCount { get; set; }
    public double SolvedRelative { get; set; }
    public int TotalCount { get; set; }
  }

  public class RunGrouper {

    public void WriteJobResults(string jobRoot, string outputPath) {
      Console.WriteLine("Write job results from {0} to {1}", jobRoot, outputPath);

      var jobResults = GetJobResults(jobRoot);

      var lines = jobResults
        .Select(GetJobResultLine)
        .ToList();

      File.WriteAllLines(outputPath, lines);
      Console.WriteLine("JobResults written");
    }

    public void WriteJobResult(string jobRoot, string outputPath) {
      var jobResult = GetJobResult(jobRoot);
      var line = GetJobResultLine(jobResult);

      File.WriteAllText(outputPath, line);
    }

    private static string GetJobResultLine(JobResult jobResult) {
      var solvedPercentage = Math.Round(jobResult.SolvedRelative * 100, 2);

      var prefix = jobResult.IsWithOffspringSelection
        ? "[OSGA]"
        : "[GA]  ";

      return string.Format(
                @"{7} {0} {1} {2} {3} {4} {5} {6}\%",
                jobResult.Name.PadRight(28),
                jobResult.Best.ToString("N4", CultureInfo.InvariantCulture).PadLeft(12),
                jobResult.AverageBest.ToString("N4", CultureInfo.InvariantCulture).PadLeft(12),
                jobResult.StandardDeviation.ToString("N4", CultureInfo.InvariantCulture).PadLeft(12),
                jobResult.SolvedCount.ToString().PadLeft(4),
                jobResult.TotalCount.ToString().PadLeft(4),
                solvedPercentage.ToString("N2").PadLeft(6),
                prefix
              );
    }

    protected virtual bool CanFileBeRead(string path) {
      return !IsFileLocked(path);
    }

    protected virtual bool IsFileLocked(string path) {
      var fileInfo = new FileInfo(path);

      return IsFileLocked(fileInfo);
    }

    protected virtual bool IsFileLocked(FileInfo file) {
      FileStream stream = null;

      try {
        stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None);
      }
      catch (IOException) {
        //the file is unavailable because it is:
        //still being written to
        //or being processed by another thread
        //or does not exist (has already been processed)
        return true;
      }
      finally {
        if (stream != null)
          stream.Close();
      }

      //file is not locked
      return false;
    }

    public IReadOnlyList<JobResult> GetJobResults(string rootPath) {
      Console.WriteLine("GetJobResults from {0}", rootPath);

      if (!Directory.Exists(rootPath)) {
        Console.WriteLine("Directory {0} not found", rootPath);
        throw new FileNotFoundException(rootPath);
      }

      var jobResults = Directory
        .EnumerateDirectories(rootPath)
        .AsParallel()
        .Select(GetJobResult)
        .OrderBy(jr => jr.Name)
        .ToList();

      Console.WriteLine("JobResults read");
      return jobResults;
    }

    public JobResult GetJobResult(string rootPath) {
      if (!Directory.Exists(rootPath)) {
        Console.WriteLine("Directory {0} not found\n", rootPath);
        throw new FileNotFoundException(rootPath);
      }

      var directoryInfo = new DirectoryInfo(rootPath);
      var name = GetJobName(directoryInfo.Name);

      Console.WriteLine("Get job {0}", name);

      var runs = this.GetRuns(rootPath);

      var bestResults = runs.Select(r => (r.Results["BestQuality"] as DoubleValue).Value).ToList();
      var best = bestResults.Min();
      var avg = bestResults.Average();
      var stdDeviation = StandardDeviation(bestResults);
      var solvedCount = bestResults.Count(x => x.IsAlmost(0));
      var totalCount = runs.Count;
      var solvedRelative = solvedCount / (double)totalCount;
      var isWithOffspringSelection = directoryInfo.Name.Contains("[Offspring GA]");

      return new JobResult {
        Name = name,
        Best = best,
        AverageBest = avg,
        StandardDeviation = stdDeviation,
        SolvedCount = solvedCount,
        SolvedRelative = solvedRelative,
        TotalCount = totalCount,
        IsWithOffspringSelection = isWithOffspringSelection
      };
    }

    private static string GetJobName(string totalName) {
      var start = totalName.LastIndexOf(']') + 2;
      var end = totalName.IndexOf('-') - 1;
      var length = end - start;

      var name = length > 0
        ? totalName.Substring(start, length)
        : totalName;

      return name;
    }

    public static double StandardDeviation(IEnumerable<double> values) {
      var avg = values.Average();
      return Math.Sqrt(values.Average(v => Math.Pow(v - avg, 2)));
    }

    public void DoAllJobs(string rootPath) {
      if (!Directory.Exists(rootPath)) {
        throw new FileNotFoundException(rootPath);
      }

      var jobDirs = Directory.EnumerateDirectories(rootPath);
      Parallel.ForEach(jobDirs, DoSingleJob);
    }

    public void DoSingleJob(string rootPath) {
      if (!Directory.Exists(rootPath)) {
        throw new FileNotFoundException(rootPath);
      }

      var directoryInfo = new DirectoryInfo(rootPath);
      var fileName = "Grouped - " + directoryInfo.Name;
      var outputPath = Path.Combine(directoryInfo.Parent.FullName, fileName + ".hl");

      if (File.Exists(outputPath)) {
        Console.WriteLine(@"Experiment {0} already exists", fileName);
        return;
      }

      var runs = GetRuns(rootPath);

      var runCollection = new RunCollection();
      runCollection.AddRange(runs);

      ContentManager.Save(runCollection, outputPath, true);
    }

    public IReadOnlyList<Run> GetRuns(string rootPath) {
      var runs = Directory
        .EnumerateFiles(rootPath)
        .AsParallel()
        .Where(CanFileBeRead)
        .Select(XmlParser.Deserialize)
        .Where(x => x is IAlgorithm)
        .Cast<IAlgorithm>()
        .Select(alg => new Run(alg))
        .ToList();

      return runs;
    }
  }
}