# Balloon.py
# Written by Benjamin T. Jolitz for SCIPP/Quarknet
# The original author must be named in all direct
# derivative programs and must be named in
# this program
# copyright 2007
# questions or changes to this program
# http://benjamin.telemuse.net/contact
# read and translate lines of data

class data :

    start_time = 0                      # beginning time of experiment (in ns)
    rollover_time = 0                   # time ticks of rollover overflow
    last_tim = 0                        # previous time stamp

    interval_time = 2*60*1000*1000*1000 # interval (in ns)
    interval_count = 1                  # number of intervals
    interval_first_line = 0             # first line of interval

    trigger_count = 0                   # number of triggers accumulating in the current interval
    trigger_next_interval = 0           # starting time for this trigger



    def __init__(self, file, ignore_start) :

        line_count = 0
        ignore_start = ignore_start * 1000 * 1000 * 1000 # convert seconds to ns
        seen_start = 0


        for line in file.readlines() :
            line_count = line_count + 1

            columns = line.strip().split(' ')

#            print len(columns)
            if  len(columns) <> 16:
                print 'data dropout, line %d, line reads: ' % line_count, columns
                continue

            # adjust time (in 24ns ticks) by advancing when it exceeds maximum value
            tim = int(columns[0], 16)
            if tim < self.last_tim :
                self.rollover_time += 4294967296

            data_timestamp = 24L * (tim + self.rollover_time) # data time stamp in nanoseconds
            self.last_tim = tim

            if self.start_time == 0 :
                # first interval
                self.start_time = data_timestamp + ignore_start # beginning of first interval
                self.trigger_next_interval = self.start_time + self.interval_time

            # ignore data before the first sample
            if data_timestamp < self.start_time :
                continue
            else :
                if seen_start == 0 :
                    seen_start = 1 
                    self.interval_first_line = line_count
                    if ignore_start <> 0 :
                        print 'ignored lines [1-%d] before interval 1' % (line_count - 1)

            #print data_timestamp

            # have we completed an interval? then print a report and reset for the next interval
            if data_timestamp >= self.trigger_next_interval :
                print "interval %04d: triggers %04d [lines %d-%d]" % (
                    self.interval_count, self.trigger_count, self.interval_first_line, line_count-1)
                self.interval_first_line = line_count
                self.interval_count = self.interval_count + 1
                self.trigger_count = 0
                self.trigger_next_interval = self.trigger_next_interval + self.interval_time

            # does this line have a trigger?
            if columns[1] == '80' : # trigger
                self.trigger_count = self.trigger_count + 1

        print 'total lines in file:', line_count



# locate and open file, read and translate time stamped data
                                

from sys import argv, exit

# find what we are to do with what
if len(argv) in [2, 3] :
    start = 0
    if len(argv) == 3 :
        start = int(argv[2])

else :
    print '%s: usage: %s datafile [ omit-first-seconds ]' % (argv[0], argv[0])
    exit(1)

datafile = open (argv[1], 'r')

data(datafile, start)