hivetimeline.py

Go to the documentation of this file.

#!/usr/bin/env python
"""Plot timeline from TimelineSvc"""
from __future__ import print_function

__author__ = "Frank Winklmeier"

import sys
import re
import argparse
import operator
from collections import defaultdict

algcolors = []
evtcolors = []

# Attributes will be added in read()


class Data:
    pass


def read(f, regex='.*', skipevents=0):
    data = []
    regex = re.compile(regex)
    for l in open(f, 'r'):
        if l.startswith('#'):  # e.g. #start end algorithm thread slot event
            names = l.lstrip('#').split()
            continue
        d = Data()
        for i, f in enumerate(l.split()):
            setattr(d, names[i], int(f) if f.isdigit() else f)
        if d.event >= skipevents:
            data.append(d)
    return data


def findEvents(data):
    """Find event start/stop times"""

    t = defaultdict(lambda: [sys.maxint, 0, -1])  # start,stop,slot
    nbslots = 0
    for d in data:
        if d.start < t[d.event][0]:
            t[d.event][0] = d.start
            t[d.event][2] = d.slot
        if d.end > t[d.event][1]:
            t[d.event][1] = d.end
        if d.slot > nbslots:
            nbslots = d.slot

    return t, nbslots


def setPalette(nevts, nevtcolors):
    global algcolors, evtcolors

    from ROOT import TColor
    algcolors = range(2, 10) + [20, 28, 29, 30, 33, 38, 40] + range(41, 50)
    evtcolors = [
        TColor.GetColor(0, 255 - g, g)
        for g in range(20, 255, (255 - 20) / nevtcolors)
    ]


def plot(data,
         showThreads=True,
         batch=False,
         nevtcolors=10,
         width=1200,
         height=500):
    import ROOT

    tmin = min(f.start for f in data)
    tmax = max(f.end for f in data)
    slots = 1 + max(f.slot for f in data)
    threads = sorted(list(set(f.thread for f in data)))
    threadid = dict((k, v) for v, k in enumerate(threads))  # map thread : id
    ymax = len(threads) if showThreads else slots

    c = ROOT.TCanvas('timeline', 'Timeline', width, height)
    c.SetLeftMargin(0.05)
    c.SetRightMargin(0.2)
    c.SetTopMargin(0.1)
    c.SetBottomMargin(0.1)
    c.coord = ROOT.TH2I('coord', ';Time (ns)', 100, 0, tmax - tmin, ymax, 0,
                        ymax)
    c.coord.GetYaxis().SetTitle(('Thread' if showThreads else 'Slot'))
    c.coord.GetYaxis().SetTitleOffset(0.5)
    c.coord.GetYaxis().CenterTitle()
    c.coord.SetStats(False)
    c.coord.GetYaxis().SetNdivisions(ymax)
    c.coord.GetXaxis().CenterTitle()

    c.Draw()
    c.coord.Draw()

    c.lines = []
    colors = {}
    setPalette(ymax, nevtcolors)
    mycolors = algcolors
    for d in data:
        y = (threadid[d.thread] if showThreads else d.slot)
        alg = d.algorithm
        if alg not in colors and len(mycolors) > 0:
            colors[alg] = mycolors.pop(0)
            if len(mycolors) == 0:
                print("Too many algorithm to show")

        if alg in colors:
            t0 = d.start - tmin
            t1 = d.end - tmin

            # Alg
            l = ROOT.TBox(t0, y + .1, t1, y + .8)
            l.SetFillColor(colors[alg])

            # Event
            l2 = ROOT.TBox(t0, y + .8, t1, y + .9)
            l2.SetFillColor(evtcolors[d.event % nevtcolors])
            c.lines += [l, l2]

            l2.Draw()
            l.Draw()

    # Global event timeline
    tevt, nbslots = findEvents(data)
    bheight = 0.1
    for k, v in tevt.iteritems():
        y = ymax + bheight * v[2]
        l = ROOT.TBox(v[0] - tmin, y + 0.2 * bheight, v[1] - tmin, y + bheight)
        l.SetFillColor(evtcolors[k % nevtcolors])
        c.lines += [l]
        l.Draw()

    # Alg legend
    c.leg = ROOT.TLegend(0.8, 0.4, 0.98, 0.9)
    for alg, cl in sorted(colors.iteritems(), key=operator.itemgetter(1)):
        e = c.leg.AddEntry('', alg, 'F')
        e.SetLineColor(cl)
        e.SetFillColor(cl)
        e.SetFillStyle(1001)

    # Event legend
    bwidth = 0.18 / nevtcolors
    for cl in range(nevtcolors):
        l = ROOT.TLine()
        c.lines.append(l)
        l.SetLineWidth(10)
        l.SetLineColor(evtcolors[cl])
        l.DrawLineNDC(0.807 + bwidth * cl, 0.37, 0.807 + bwidth * (cl + 1),
                      0.37)

    c.t1 = ROOT.TText(0.807, 0.314, 'Events')
    c.t1.SetNDC()
    c.t1.SetTextFont(42)
    c.t1.SetTextSize(0.04)
    c.t1.Draw()

    c.t2 = ROOT.TText(0.02, 0.92, 'Event')
    c.t2.SetNDC()
    c.t2.SetTextFont(42)
    c.t2.SetTextSize(0.03)
    c.t2.SetTextAngle(90)
    c.t2.Draw()
    c.t3 = ROOT.TText(0.03, 0.922, 'Slots')
    c.t3.SetNDC()
    c.t3.SetTextFont(42)
    c.t3.SetTextSize(0.03)
    c.t3.SetTextAngle(90)
    c.t3.Draw()

    c.leg.Draw()
    c.Update()
    if not batch:
        raw_input()
    return c


def main():
    parser = argparse.ArgumentParser(description=__doc__)

    parser.add_argument('timeline', nargs=1, help='timeline file')

    parser.add_argument(
        '-s',
        '--select',
        default='.*',
        help='Regular expression to filter algorithms')

    parser.add_argument(
        '-b',
        '--batch',
        action='store_true',
        default=False,
        help='Do not wait for user input')

    parser.add_argument(
        '--slots',
        action='store_true',
        default=False,
        help='Show slots instead of threads (leads to overlaps!)')

    parser.add_argument(
        '-p',
        '--print',
        dest='outfile',
        nargs='?',
        const='timeline.png',
        help='Save to FILE [%(const)s]')

    parser.add_argument(
        '-n',
        '--nevtcolors',
        default=10,
        type=int,
        help='Number of colors used for events (10 is default)')

    parser.add_argument(
        '-e',
        '--skipevents',
        default=0,
        type=int,
        help='Number of events to skip at the start')

    parser.add_argument(
        '-x',
        '--width',
        default=1200,
        type=int,
        help='width of the output picture')

    parser.add_argument(
        '-y',
        '--height',
        default=500,
        type=int,
        help='height of the output picture')

    args = parser.parse_args()

    data = read(args.timeline[0], args.select, args.skipevents)
    c = plot(data, not args.slots, args.batch, args.nevtcolors, args.width,
             args.height)
    if args.outfile:
        c.SaveAs(args.outfile)

    return 0


if __name__ == '__main__':
    sys.exit(main())