source: branches/2929_PrioritizedGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.PGE/3.3/go-code/src/go-pge/main_post.go

package main

import (
  "bufio"
  "bytes"
  "fmt"
  "io/ioutil"
  "os"
  exec "os/exec"
  "sort"
  "text/template"
)

func post(DS *MainSearch) {

  fmt.Printf("\n\nMain - Post Processing\n======================\n\n")

  DC := DS.cnfg
  // setup log dir and open main log files
  basedir, _ := os.Open(DC.logDir)
  subdirs, _ := basedir.Readdirnames(0)
  sort.Strings(subdirs)

  for _, sdir := range subdirs {
    processProblemDir(sdir, DC.logDir+sdir)
  }

}

func processProblemDir(probstr, dirstr string) {
  outdir := "out/bench/" + probstr

  pdir, _ := os.Open(dirstr)
  rundirs, _ := pdir.Readdirnames(0)
  sort.Strings(rundirs)
  fmt.Printf("ProbDir %s\n", probstr)

  var results []runResults
  for r, rdir := range rundirs {
    ret := processRunDir(r, dirstr+"/"+rdir)
    results = append(results, ret)
  }

  var genErr []aveErr
  for j := 1; j < len(results[0].genErr); j++ {
    ave, best := 0.0, 0.0
    for i := 0; i < len(results); i++ {
      if results[i].genErr[j].gen < 1 {
        continue
      }
      // fmt.Printf("%d %d %d\n", i, j, results[i].genErr[j].gen)
      ave += results[i].genErr[j].err
      best += results[i].genErr[j].best
    }
    gen := j * 10
    ave /= float64(len(results))
    best /= float64(len(results))
    tmp := aveErr{gen, ave, best}
    fmt.Printf("Gen: %v\n", tmp)

    genErr = append(genErr, tmp)
  }

  makeGraph(probstr, outdir, genErr)

  fmt.Println("\n\n\n")
}

type aveErr struct {
  gen  int
  err  float64
  best float64
}

type bestEqn struct {
  pos     int
  eqn_str string
  latex   string
  size    int
  err     float64
}

type runResults struct {
  genErr []aveErr
  eqns   []bestEqn
}

func processRunDir(run int, dirstr string) (ret runResults) {

  fmt.Println("  run ", run, " ", dirstr)

  ret.genErr = make([]aveErr, 101)

  gpsr_eqn_data, _ := ioutil.ReadFile(dirstr + "/gpsr/gpsr:eqns.log")
  lines := bytes.Split(gpsr_eqn_data, []byte("\n"))

  var (
    str, tmp         string
    gen, cnt         int
    pos, size        int
    terr, tsum, tmin float64
    latex, eqn_str   string
  )

  for l := 0; l < len(lines); l++ {
    _, err := fmt.Sscanf(string(lines[l]), "%s %d %d", &str, &gen, &cnt)
    if err != nil {
      // fmt.Println("Err on GEN line: ", err)
      break
    }
    // fmt.Println("    Gen: ", gen)
    tsum = 0.0
    tmin = 1000000.0
    for i := 0; i < cnt; i++ {
      l++
      fmt.Sscanf(string(lines[l]), "%d", &pos)
      latex = string(bytes.TrimSpace(lines[l][2:]))
      l++
      eqn_str = string(lines[l])
      l++
      fmt.Sscanf(string(lines[l]), "%s %d", &str, &size)
      l += 5
      fmt.Sscanf(string(lines[l]), "%s %s %f", &str, &tmp, &terr)
      if terr < tmin {
        tmin = terr
      }
      tsum += terr
      l += 2
      _ = latex
      _ = eqn_str

      if gen == 1000 {
        var eqn bestEqn
        eqn.pos = i
        eqn.eqn_str = eqn_str
        eqn.latex = latex
        eqn.err = terr
        eqn.size = size
        ret.eqns = append(ret.eqns, eqn)
        // if i < 12 {
        //  fmt.Printf("    %d %s  %d %f\n", i, latex, size, terr)
        // }
      }
    }
    var gerr aveErr
    gerr.gen = gen
    gerr.err = terr
    gerr.best = tmin
    ret.genErr[gen/10] = gerr
    // fmt.Printf("Gen: %d  %f  %f\n", gen, tsum/float64(cnt), tmin)

  }
  return
}

func makeGraph(prob, dir string, genErr []aveErr) {

  dataFN := dir + "/errData.txt"
  gnuFN := dir + "/plotData.gnu"
  plotFN := dir + "/" + prob

  dataFile, _ := os.Create(dataFN)
  out := bufio.NewWriter(dataFile)

  for _, pnt := range genErr {
    fmt.Fprintln(out, pnt.gen, pnt.err, pnt.best)
  }

  out.Flush()
  dataFile.Close()

  pInfo := plotInfo{plotFN, dataFN, prob}

  gnuFile, _ := os.Create(gnuFN)
  gout := bufio.NewWriter(gnuFile)

  tmpl, err := template.New("gnu").Parse(plot_file)
  if err != nil {
    panic(err)
  }
  err = tmpl.Execute(gout, pInfo)
  if err != nil {
    panic(err)
  }

  gout.Flush()
  gnuFile.Close()

  cmd := exec.Command("gnuplot", gnuFN)
  err = cmd.Run()
  if err != nil {
    panic(err)
  }
}

type plotInfo struct {
  Outfn string
  Infn  string
  Prob  string
}

var plot_file = `
set term postscript enhanced
set output '{{.Outfn}}.png'

set style line 1 lt 1 lc rgb "blue" lw 1
set style line 2 lt 1 lc rgb "black" lw 1
set style line 3 lt 1 lc rgb "red" lw 1
set autoscale
plot '{{.Infn}}' using 1:2 with lines ls 2, '' using 1:3 with lines ls 1

`

var eqn_tex_file = `
\subsection*\{ {{}} \}

`