plot-statistics.py

Go to the documentation of this file.

# This file is part of the ExaHyPE2 project. For conditions of distribution and
# use, please see the copyright notice at www.peano-framework.org
import argparse
import os
 
import matplotlib.pyplot as plt
 
 
Colours = [ "#ff0000",
            "#00ff00",
            "#0000ff",
            "#ff00ff",
            "#ffff00",
            "#00ffff",
          ]
 
Markers = [
            "v",
            "^",
            "x",
            "o",
            "<",
            ">"
          ]
 
if __name__ == "__main__":
  """!
  
  Script to postprocess statistics outcomes
  
  This script can produce two types of data: a CSV file which contains only
  specific data (it then serves as a filter to a bigger CSV file), or a plot
  of specific data. For the plot, we can either dump data as scatter plot, 
  or we can use historic data. After all, all data are time series, so we
  end up with some kind of step function plot for the latter.
  
  
  """
  parser = argparse.ArgumentParser(description="""
Peano 4 statistics postprocessing
 
Plotter for statistics over time. The plotter works only for numerical
data dumped as four tuple over time. Use inspect-statistics.py first
to see what the indices of the individual column are and what semantics
they have.
 
""")
  parser.add_argument("file", help="filename of examine")
  parser.add_argument("-c", 
                      "--columns", 
                      dest="columns", 
                      help="comma-separated list of columns to read (0 equals time stamps and is read always)", 
                      required=True)
  parser.add_argument("-o", 
                      "--output",  
                      dest="output",    
                      help="Pick plot variant", 
                      choices=[ "pdf", "png", "csv" ], 
                      required=True)
  parser.add_argument("-pt", 
                      "--plot-type",  
                      dest="plot_type",    
                      help="Pick plot variant (ignored for csv)", 
                      choices=[ "scatter", "step" ], 
                      required=True)
  parser.add_argument("-minmax", 
                      "--min-max",  
                      dest="minmax",
                      action="store_true",
                      default=False,    
                      help="Write min-max bars" )
  parser.add_argument("-v", 
                      "--verbose",  
                      dest="verbose",
                      action="store_true",
                      default=False,    
                      help="Verbose" )
  args = parser.parse_args()
  
  columns = [ int(x) for x in args.columns.split(",") ]
  print( "Extract columns {}".format(columns) )
  
  if args.output=="pdf" or args.output=="png":    
    plt.clf()
 
  for column in columns:
    #
    # Every entry of interest is characterised through a time stamp and a 
    # measurement output from Peano. Measureemnt outputs always tell you 
    # the (average) value, the min value, the max value and the number of 
    # samples.
    #
    timestamps = []
    values     = []
    min_values = []
    max_values = []
    samples    = []
  
    #
    # Read input file
    #
    input_file = open( args.file, "r" )
    metric = None
    for line in input_file:
      if metric==None:
        # If metric still equals None, then we are in the very
        # first line, and we use this first line to extract the
        # metric from the input file
        metric = line.split( "," )[column]
        print( "parse metric {}".format(metric) )
      elif line.strip()!="":
        time_stamp = float(line.split( "," )[0])
        token      = line.split( "," )[column].strip()
        if len(timestamps)>0 and time_stamp<timestamps[-1]:
          print( "data consistency error for data at {}, as last time stamp had been {}".format(time_stamp,timestamps[-1]) )
        if token!="":
          timestamps.append(time_stamp )
          value = float( token.split("(")[1].split("/")[0])
          values.append( value )
          min_values.append( float( token.split("/")[1])  )
          max_values.append( float( token.split("/")[2])  )
          samples.append( float( token.split("/#")[1].split(")")[0])  )
        elif args.plot_type=="step" and len(timestamps)>0:
          timestamps.append(time_stamp )
          values.append( values[-1] )
          min_values.append( min_values[-1] )
          max_values.append( max_values[-1] )
          samples.append( samples[-1] )
          
    #
    # Dump csv
    #
    if args.verbose:
      print( "dump {} data points for label {}".format(len(timestamps),metric) )    
    if args.output=="csv":
      output_file = open( args.file + "-column-" + str(column) + ".csv", "w" )
      output_file.write( "time, value, min, max, count\n" )
      for data in zip(timestamps,values,min_values,max_values,samples):
        entries_per_row = 5
        for i in range(0,entries_per_row-1):
          output_file.write( str(data[i]) )
          output_file.write( "," )
        output_file.write( str(data[entries_per_row-1]) )
        output_file.write( "\n" )
    if (args.output=="pdf" or args.output=="png") and args.plot_type=="step":
      assert len(timestamps)==len(values)
      colour = columns.index(column) % len(Colours)
      if args.minmax:
        for i in zip(timestamps,min_values,max_values):
          plt.plot( [i[0],i[0]], [i[1],i[2]], color=Colours[colour] )
      plt.plot( timestamps, values, color=Colours[colour], alpha=0.5, label=metric )
    if (args.output=="pdf" or args.output=="png") and args.plot_type=="scatter":
      assert len(timestamps)==len(values)
      colour = columns.index(column) % len(Colours)
      if args.minmax:
        for i in zip(timestamps,min_values,max_values):
          plt.plot( [i[0],i[0]], [i[1],i[2]], color=Colours[colour] )
      plt.scatter( timestamps, values, marker=Markers[colour], color=Colours[colour], alpha=0.5, label=metric )
 
  plt.rc('legend', fontsize = 6)
  
  if args.output=="pdf":    
    plt.legend()
    plt.savefig( args.file + ".pdf" )
  if args.output=="png":    
    plt.legend()
    plt.savefig( args.file + ".png" )