def main():
    _log = log.init_logging("main")

    vhdl_dict = VHDLConstantsParser.parse_vhdl_file("data/ugmt_constants.vhd")

    basedir_testbench = "data/patterns/emu/"
    rankLUT = l1t.MicroGMTRankPtQualLUT()

    options = parse_options()
    file_dict = discover_files(options)
    for pattern, fnames in file_dict.iteritems():
        _log.info("{patt:+^90}".format(patt=pattern))

        _log.info("{info:>90}".format(info="HW PARSING"))
        # Reading and processing the hardware data
        input_parser = InputBufferParser(fnames["rx"], vhdl_dict)
        in_muons = input_parser.get_input_muons()

        input_testbench = PatternDumper(basedir_testbench + pattern + ".txt",
                                        vhdl_dict, TestbenchWriter)
        offset = 36
        fwdp_range = range(offset + vhdl_dict["FWD_POS_LOW"],
                           offset + vhdl_dict["FWD_POS_HIGH"])
        fwdn_range = range(offset + vhdl_dict["FWD_NEG_LOW"],
                           offset + vhdl_dict["FWD_NEG_HIGH"])
        bar_range = range(offset + vhdl_dict["BARREL_LOW"],
                          offset + vhdl_dict["BARREL_HIGH"])
        ovlp_range = range(offset + vhdl_dict["OVL_POS_LOW"],
                           offset + vhdl_dict["OVL_POS_HIGH"])
        ovln_range = range(offset + vhdl_dict["OVL_NEG_LOW"],
                           offset + vhdl_dict["OVL_NEG_HIGH"])

        while len(in_muons) > 0:
            bar_muons = []
            ovlp_muons = []
            ovln_muons = []
            fwdp_muons = []
            fwdn_muons = []
            for i in range(108):
                mu = in_muons[0]
                if mu.link in fwdp_range: fwdp_muons.append(mu)
                if mu.link in fwdn_range: fwdn_muons.append(mu)
                if mu.link in ovlp_range: ovlp_muons.append(mu)
                if mu.link in ovln_range: ovln_muons.append(mu)
                if mu.link in bar_range: bar_muons.append(mu)

                del in_muons[0]

            input_testbench.writeMuonBasedInputBX(bar_muons, fwdp_muons,
                                                  fwdn_muons, ovlp_muons,
                                                  ovln_muons, [], rankLUT,
                                                  False, True)
        input_testbench.dump()
    
    print '-'*40
    print 'MP7 muon input conversion script'
    print '-'*40

    #test(8); test(9); test(2); test(10)
    frames = []

    for i in xrange(72):
        frames.append([])


    # convert this to commandline option together with out file
    infile = open(opts.infile, "r")
    outfile = open(opts.outfile, "w")
    cfg = VHDLConstantsParser.parse_vhdl_file(opts.config)
    print cfg
    newEvt = False
    evts = 0
    counters_tot = {
        "brl" : 0,
        "fwd_pos" : 0,
        "fwd_neg" : 0,
        "ovl_pos" : 0,
        "ovl_neg" : 0,
        "calo": 0
    }
    counters = counters_tot.copy()

    frames_string = ""
    cur_frames = {}
Esempio n. 3
0
def main():
    vhdl_dict = VHDLConstantsParser.parse_vhdl_file("data/ugmt_constants.vhd")

    opts = parse_options()
    nMax = opts.nMax
    skip = opts.skip
    fname_dict = discover_emu_files(opts.emudirectory)
    # rankLUT = l1t.MicroGMTRankPtQualLUT()

    for pattern, fnames in fname_dict.iteritems():
        print "+" * 30, pattern, "+" * 30
        events = Events(fnames['root'])

        start = time.time()

        tower_indices = None
        if 'idebug' in fnames.keys():
            debug_fname = fnames['idebug']
            with open(debug_fname, 'r') as fobj:
                tower_indices = [[int(idx.strip()) for idx in l.split()]
                                 for l in fobj]

        out_handle = Handle('BXVector<l1t::Muon>')
        imd_bmtf_handle = Handle('BXVector<l1t::Muon>')
        imd_emtf_p_handle = Handle('BXVector<l1t::Muon>')
        imd_emtf_n_handle = Handle('BXVector<l1t::Muon>')
        imd_omtf_p_handle = Handle('BXVector<l1t::Muon>')
        imd_omtf_n_handle = Handle('BXVector<l1t::Muon>')
        bar_handle = Handle('BXVector<l1t::RegionalMuonCand>')
        fwd_handle = Handle('BXVector<l1t::RegionalMuonCand>')
        ovl_handle = Handle('BXVector<l1t::RegionalMuonCand>')
        calo_handle = Handle('BXVector<l1t::MuonCaloSum>')

        basedir_testbench = "data/patterns/testbench/"
        basedir_mp7 = "data/patterns/mp7/"

        input_buffer = PatternDumper(basedir_mp7 + pattern + ".txt", vhdl_dict,
                                     BufferWriter)
        output_buffer = PatternDumper(basedir_mp7 + pattern + "_out.txt",
                                      vhdl_dict, BufferWriter)
        input_testbench = PatternDumper(basedir_testbench + pattern + ".txt",
                                        vhdl_dict, TestbenchWriter)
        serializer_testbench = PatternDumper(
            basedir_testbench + "serializer_" + pattern + ".txt", vhdl_dict,
            TestbenchWriter)
        deserializer_testbench = PatternDumper(
            basedir_testbench + "deserializer_" + pattern + ".txt", vhdl_dict,
            TestbenchWriter)
        integration_testbench = PatternDumper(
            basedir_testbench + "integration_" + pattern + ".txt", vhdl_dict,
            TestbenchWriter)

        if opts.delay > 0:
            input_buffer.writeEmptyFrames(opts.delay)

        setup_time = time.time() - start

        avg_get_label_time = 0
        avg_conversion_time = 0
        avg_write_time = 0
        n_twrs = 0
        for i, event in enumerate(events):
            if i < skip:
                continue
            if nMax > 0 and i - skip > nMax:
                break
            evt_start = time.time()
            event_head = "#" * 80 + "\n"
            event_head += "# Event: {ievent}\n".format(ievent=i)
            event_head += "#" * 80 + "\n"
            input_testbench.addLine(event_head)
            serializer_testbench.addLine(event_head)
            deserializer_testbench.addLine(event_head)
            integration_testbench.addLine(event_head)

            event.getByLabel("simGmtStage2Digis", out_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsBMTF",
                             imd_bmtf_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsEMTFPos",
                             imd_emtf_p_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsEMTFNeg",
                             imd_emtf_n_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsOMTFPos",
                             imd_omtf_p_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsOMTFNeg",
                             imd_omtf_n_handle)
            event.getByLabel("simBmtfDigis", "BMTF", bar_handle)
            event.getByLabel("simEmtfDigis", "EMTF", fwd_handle)
            event.getByLabel("simOmtfDigis", "OMTF", ovl_handle)
            #event.getByLabel("gmtStage2Digis", "BMTF", bar_handle)
            #event.getByLabel("gmtStage2Digis", "EMTF", fwd_handle)
            #event.getByLabel("gmtStage2Digis", "OMTF", ovl_handle)

            event.getByLabel("simGmtCaloSumDigis", "TriggerTowerSums",
                             calo_handle)
            #event.getByLabel("emptyCaloCollsProducer", "EmptyTriggerTowerSums", calo_handle)
            #event.getByLabel("simGmtCaloSumDigis", "TriggerTower2x2s", calo_handle)
            get_label_time = time.time() - evt_start
            calo_sums_raw = calo_handle.product()
            calo_sums = get_calo_list(calo_sums_raw)

            emu_out_muons = out_handle.product()
            outmuons = get_muon_list_out(emu_out_muons, "OUT", vhdl_dict)
            serializermuons = get_muon_list_out(emu_out_muons, "SER",
                                                vhdl_dict)
            imd_emtf_p_prod = imd_emtf_p_handle.product()
            imdmuons = get_muon_list_out(imd_emtf_p_prod, "IMD", vhdl_dict, 4)
            imd_omtf_p_prod = imd_omtf_p_handle.product()
            imdmuons += get_muon_list_out(imd_omtf_p_prod, "IMD", vhdl_dict, 4)
            imd_bmtf_prod = imd_bmtf_handle.product()
            imdmuons += get_muon_list_out(imd_bmtf_prod, "IMD", vhdl_dict, 8)
            imd_omtf_n_prod = imd_omtf_n_handle.product()
            imdmuons += get_muon_list_out(imd_omtf_n_prod, "IMD", vhdl_dict, 4)
            imd_emtf_n_prod = imd_emtf_n_handle.product()
            imdmuons += get_muon_list_out(imd_emtf_n_prod, "IMD", vhdl_dict, 4)

            emu_bar_muons = bar_handle.product()
            bar_muons = get_muon_list(emu_bar_muons, "BMTF", vhdl_dict, i)
            emu_ovl_muons = ovl_handle.product()
            ovlp_muons = get_muon_list(emu_ovl_muons, "OMTF_POS", vhdl_dict, i)
            ovln_muons = get_muon_list(emu_ovl_muons, "OMTF_NEG", vhdl_dict, i)
            emu_fwd_muons = fwd_handle.product()
            fwdp_muons = get_muon_list(emu_fwd_muons, "EMTF_POS", vhdl_dict, i)
            fwdn_muons = get_muon_list(emu_fwd_muons, "EMTF_NEG", vhdl_dict, i)

            conversion_time = time.time() - evt_start - get_label_time
            input_buffer.writeFrameBasedInputBX(bar_muons, fwdp_muons,
                                                fwdn_muons, ovlp_muons,
                                                ovln_muons, calo_sums)
            integration_testbench.writeFrameBasedInputBX(
                bar_muons, fwdp_muons, fwdn_muons, ovlp_muons, ovln_muons,
                calo_sums)
            deserializer_testbench.writeFrameBasedInputBX(
                bar_muons, fwdp_muons, fwdn_muons, ovlp_muons, ovln_muons,
                calo_sums)
            output_buffer.writeFrameBasedOutputBX(outmuons, imdmuons)

            input_testbench.writeMuonBasedInputBX(bar_muons,
                                                  fwdp_muons,
                                                  fwdn_muons,
                                                  ovlp_muons,
                                                  ovln_muons,
                                                  calosums=calo_sums,
                                                  addTracks=True)
            input_testbench.addLine("# Expected emulator output\n")
            input_testbench.writeMuonBasedOutputBX(outmuons, imdmuons)
            deserializer_testbench.addLine("# Expected emulator output\n")
            deserializer_testbench.writeMuonBasedInputBX(bar_muons,
                                                         fwdp_muons,
                                                         fwdn_muons,
                                                         ovlp_muons,
                                                         ovln_muons,
                                                         calosums=calo_sums,
                                                         addTracks=True)
            if tower_indices is not None:
                input_testbench.addLine("# Tower indices:\n")
                cntr = 0
                for mu in outmuons:
                    if mu.bitword != 0:
                        cntr += 1
                input_testbench.writeTowerIndices(tower_indices[n_twrs:n_twrs +
                                                                cntr])
                n_twrs += cntr

            serializer_testbench.writeMuonBasedOutputBX(
                serializermuons, imdmuons)
            serializer_testbench.addLine("# Expected emulator output\n")
            serializer_testbench.writeFrameBasedOutputBX(
                serializermuons, imdmuons)
            integration_testbench.addLine("# Expected emulator output\n")
            integration_testbench.writeFrameBasedOutputBX(outmuons, imdmuons)
            write_time = time.time() - evt_start - conversion_time
            avg_get_label_time += get_label_time
            avg_conversion_time += conversion_time
            avg_write_time += write_time
        print "total: ", time.time() - start
        print "setup: ", setup_time
        print "get_label:", "avg", avg_get_label_time / float(
            i + 1), "last", get_label_time
        print "conversion: avg", avg_conversion_time / float(
            i + 1), "last", conversion_time
        print "write: avg", avg_write_time / float(i + 1), "last", write_time
        output_buffer.dump(True)
        input_testbench.dump()
        serializer_testbench.dump()
        deserializer_testbench.dump()
        input_buffer.dump()
        integration_testbench.dump()
Esempio n. 4
0
def main():
    opts = parse_options()
    file_list_rx = []
    file_list_tx = []
    pattern_name = ""

    for root, dirs, files in os.walk(opts.directory):
        for fname in files:
            if fname.startswith('tx_') and fname.endswith('.zip'):
                # strip leading tx_ and _<i>.zip
                pattern_name = fname[3:-6]
                file_list_tx.append(root + fname)
            if fname.startswith('rx_') and fname.endswith('.zip'):
                file_list_rx.append(root + fname)

    known_responses = []
    if opts.testpath != '':
        for root, dirs, files in os.walk(opts.testpath):
            for fname in files:
                if fname.startswith('tx_'):
                    known_responses.append(root + fname)

    # this should make them synchronised
    file_list_rx.sort()
    file_list_tx.sort()
    known_responses.sort()

    if len(file_list_rx) != len(file_list_tx):
        print "Number of RX and TX files not the same!"
        return

    print "-" * 30, pattern_name, "-" * 30
    print "Starting test: A total of {i} files will be fed into the algorithm".format(
        i=len(file_list_rx))
    log = open('{pattern}.log'.format(pattern=pattern_name), 'w')

    vhdl_cfg = VHDLConstantsParser.parse_vhdl_file("data/ugmt_constants.vhd")
    analyser = Analyser('tx_tmp.txt', 'tmp/tx_summary.txt', vhdl_cfg)

    for i in range(len(file_list_rx)):
        cmp_rx = file_list_rx[i]
        cmp_tx = file_list_tx[i]
        rx_tmp_name = 'rx_tmp.txt'
        tx_tmp_name = 'tx_tmp.txt'
        decompress(rx_tmp_name, cmp_rx)
        decompress(tx_tmp_name, cmp_tx)

        cap_lines = []
        if opts.testpath == '':
            butler_out = ''
            if opts.p5:
                butlerError = subprocess.call([
                    'mp7butler.py', '-c', opts.connections_file, 'buffers',
                    opts.boardname, 'algoPlay', '--inject',
                    'file://{fname}'.format(fname=rx_tmp_name), '-e', '36-71'
                ])
                butlerError += subprocess.call([
                    'mp7butler.py', '-c', opts.connections_file, 'buffers',
                    opts.boardname, 'algoPlay', '--inject',
                    'file://{fname}'.format(fname=rx_tmp_name), '-e', '0-35',
                    '--play', '{delay}'.format(delay=opts.en_delay)
                ])
                if butlerError != 0:
                    print " errors in mp7_butler: " + str(butlerError)
                    return
            else:
                try:
                    subprocess.check_output([
                        'mp7butler.py', '-c', opts.connections_file, 'buffers',
                        opts.boardname, 'algoPlay', '--inject',
                        'file://{fname}'.format(fname=rx_tmp_name), '-e',
                        '36-71'
                    ])
                    subprocess.check_output([
                        'mp7butler.py', '-c', opts.connections_file, 'buffers',
                        opts.boardname, 'algoPlay', '--inject',
                        'file://{fname}'.format(fname=rx_tmp_name), '-e',
                        '0-35', '--play', '{delay}'.format(delay=opts.en_delay)
                    ])
                except subprocess.CalledProcessError as e:
                    print " errors in mp7_butler: " + str(e)
                    return
            log.write(butler_out)
            time.sleep(1)
            if opts.p5:
                butlerError = subprocess.call([
                    'mp7butler.py', '-c', opts.connections_file, 'capture',
                    opts.boardname, '--outputpath', 'tmp'
                ])
                if butlerError != 0:
                    print " errors in mp7_butler: " + str(e)
                    return
            else:
                try:
                    subprocess.check_output([
                        'mp7butler.py', '-c', opts.connections_file, 'capture',
                        opts.boardname, '--outputpath', 'tmp'
                    ])
                except subprocess.CalledProcessError as e:
                    print " errors in mp7_butler: " + str(e)
                    return
            log.write(butler_out)

            cap_lines = []
            with open('tmp/tx_summary.txt', 'r') as cap:
                cap_lines = cap.readlines()
                # if opts.dump:
                #     with open(opts.outpath+'/tx_summary_{x}.txt'.format(x=i), 'w') as ofile:
                #         for lin in cap_lines:
                #             ofile.write(lin)
            # if opts.dump:
            #     with open('tmp/rx_summary.txt', 'r') as cap:
            #         with open(opts.outpath+'/rx_summary_{x}.txt'.format(x=i), 'w') as ofile:
            #             ofile.write(cap.read())

        else:
            with open(known_responses[i], 'r') as cap:
                cap_lines = cap.readlines()
            analyser.hwfname = known_responses[i]

        # quick analysis whether the tx buffers are the same
        emu_lines = []
        with open(tx_tmp_name, 'r') as emu:
            emu_lines = emu.readlines()

        diff = difflib.context_diff(emu_lines, cap_lines)
        have_errors = False
        for d in diff:
            if d.startswith("***************"):
                have_errors = True
                break
        # if they are not: do detailed analysis
        if have_errors:
            analyser.analyse(i)

    # print summary and write details to log
    analyser.print_out(pattern_name, log)
    log.close()
    instance_string = instance_string + '" AREA_GROUP=quad_'
    instance_string = instance_string + str(area_group)
    instance_string = instance_string + ';'
    return instance_string


_log = log.init_logging("ucf_serdes_constraints_generator")
if __name__ == "__main__":
    # initialize command line input
    opts, args = parse_options()

    # set verbosity according to option
    log.set_level(opts.verbosity)
    _log.debug("*" * 40)
    _log.info("  UCF Serdes constraints generator")
    _log.info("*" * 40)
    _log.info("Paste the following into your ucf file:")

    config_dict = VHDLConstantsParser.parse_vhdl_file(opts.files[0])
    quad_dict = get_quad_areagroup_mapping(opts.files[1])

    for key in sorted(config_dict):
        if "MU_QUAD_ASSIGNMENT" in key:
            for i in range(len(config_dict[key])):
                print generate_instance_string(
                    "MU", i, quad_dict[str(config_dict[key][i])])
        if "ENERGY_QUAD_ASSIGNMENT" in key:
            for i in range(len(config_dict[key])):
                print generate_instance_string(
                    "CALO", i, quad_dict[str(config_dict[key][i])])
def main():
    opts = parse_options()
    file_list_rx = []
    file_list_tx = []
    pattern_name = ""

    for root, dirs, files in os.walk(opts.directory):
        for fname in files:
            if fname.startswith('tx_') and fname.endswith('.zip'):
                # strip leading tx_ and _<i>.zip
                pattern_name = fname[3:-6]
                file_list_tx.append(root+fname)
            if fname.startswith('rx_') and fname.endswith('.zip'):
                file_list_rx.append(root+fname)

    known_responses = []
    if opts.testpath != '':
        for root, dirs, files in  os.walk(opts.testpath):
            for fname in files:
                if fname.startswith('tx_'):
                    known_responses.append(root+fname)

    # this should make them synchronised
    file_list_rx.sort(); file_list_tx.sort(); known_responses.sort()

    if len(file_list_rx) != len(file_list_tx):
        print "Number of RX and TX files not the same!"
        return

    print "-"*30, pattern_name, "-"*30
    print "Starting test: A total of {i} files will be fed into the algorithm".format(i=len(file_list_rx))
    log = open('{pattern}.log'.format(pattern=pattern_name), 'w')

    vhdl_cfg = VHDLConstantsParser.parse_vhdl_file("data/ugmt_constants.vhd")
    analyser = Analyser('tx_tmp.txt', 'tmp/tx_summary.txt', vhdl_cfg)

    for i in range(len(file_list_rx)):
        cmp_rx = file_list_rx[i]
        cmp_tx = file_list_tx[i]
        rx_tmp_name = 'rx_tmp.txt'
        tx_tmp_name = 'tx_tmp.txt'
        decompress(rx_tmp_name, cmp_rx)
        decompress(tx_tmp_name, cmp_tx)

        cap_lines = []
        if opts.testpath == '':
            butler_out = ''
            butlerError = subprocess.call(['mp7butler.py', 'buffers', opts.boardname, 'algoPlay', '--inject', 'file://{fname}'.format(fname=rx_tmp_name), '-e 36-71'])
            butlerError = subprocess.call(['mp7butler.py', 'buffers', opts.boardname, 'algoPlay', '--inject', 'file://{fname}'.format(fname=rx_tmp_name), '-e 0-35', '--play {delay}'.format(delay=opts.en_delay)])
	    if butlerError != 0:
                print " errors in mp7_butler: "+str(butlerError)
                return
            log.write(butler_out)
            time.sleep(1)
            butlerError = subprocess.call(['mp7butler.py', 'capture', opts.boardname, '--outputpath', 'tmp'])
	    if butlerError != 0:
                print " errors in mp7_butler: "+str(e)
                return
            log.write(butler_out)

            cap_lines = []
            with open('tmp/tx_summary.txt', 'r') as cap:
                cap_lines = cap.readlines()
                # if opts.dump:
                #     with open(opts.outpath+'/tx_summary_{x}.txt'.format(x=i), 'w') as ofile:
                #         for lin in cap_lines:
                #             ofile.write(lin)
            # if opts.dump:
            #     with open('tmp/rx_summary.txt', 'r') as cap:
            #         with open(opts.outpath+'/rx_summary_{x}.txt'.format(x=i), 'w') as ofile:
            #             ofile.write(cap.read())


        else:
            with open(known_responses[i], 'r') as cap:
                cap_lines = cap.readlines()
            analyser.hwfname = known_responses[i]

        # quick analysis whether the tx buffers are the same
        emu_lines = []
        with open(tx_tmp_name, 'r') as emu:
            emu_lines = emu.readlines()


        diff = difflib.context_diff(emu_lines, cap_lines)
        have_errors = False
        for d in diff:
            if d.startswith("***************"):
                have_errors = True
                break
        # if they are not: do detailed analysis
        if have_errors:
            analyser.analyse(i)

    # print summary and write details to log
    analyser.print_out(pattern_name, log)
    log.close()
        in_match_dict[mu_out] = [0, None]
        for mu_in in inmus:
            relation = calculate_relation(mu_in, mu_out)
            if in_match_dict[mu_out][0] < relation:
                in_match_dict[mu_out] = [relation, mu_in]
        imd_match_dict[mu_out] = [0, None]
        for idx, mu_imd in enumerate(imdmus):
            relation = calculate_relation(mu_imd, mu_out)
            #if relation isn't just random, put it in the dict
            if imd_match_dict[mu_out][0] < relation and relation > 19: 
                imd_match_dict[mu_out] = [relation, mu_imd]

    return in_match_dict, imd_match_dict

if __name__ == "__main__":
    vhdl_dict = VHDLConstantsParser.parse_vhdl_file("data/ugmt_constants.vhd")

    options = parse_options()
    file_dict = discover_files(options)

    for pattern, fnames in file_dict.iteritems():
        version = Version.from_filename(fnames['rx'])
        print "+"*30, pattern, "+"*30

        # Reading and processing the hardware data
        input_parser = InputBufferParser(fnames['rx'], vhdl_dict)
        output_parser = OutputBufferParser(fnames['tx'], vhdl_dict, version)

        in_muons = input_parser.get_input_muons()
        out_muons = output_parser.get_output_muons()
        imd_muons = output_parser.get_intermediate_muons()
Esempio n. 8
0
        for mu_in in inmus:
            relation = calculate_relation(mu_in, mu_out)
            if in_match_dict[mu_out][0] < relation:
                in_match_dict[mu_out] = [relation, mu_in]
        imd_match_dict[mu_out] = [0, None]
        for idx, mu_imd in enumerate(imdmus):
            relation = calculate_relation(mu_imd, mu_out)
            #if relation isn't just random, put it in the dict
            if imd_match_dict[mu_out][0] < relation and relation > 19:
                imd_match_dict[mu_out] = [relation, mu_imd]

    return in_match_dict, imd_match_dict


if __name__ == "__main__":
    vhdl_dict = VHDLConstantsParser.parse_vhdl_file("data/ugmt_constants.vhd")

    options = parse_options()
    file_dict = discover_files(options)

    for pattern, fnames in file_dict.iteritems():
        version = Version.from_filename(fnames['rx'])
        print "+" * 30, pattern, "+" * 30

        # Reading and processing the hardware data
        input_parser = InputBufferParser(fnames['rx'], vhdl_dict)
        output_parser = OutputBufferParser(fnames['tx'], vhdl_dict, version)

        in_muons = input_parser.get_input_muons()
        out_muons = output_parser.get_output_muons()
        imd_muons = output_parser.get_intermediate_muons()
    instance_string = instance_string + '" AREA_GROUP=quad_'
    instance_string = instance_string + str(area_group)
    instance_string = instance_string + ';'
    return instance_string
    

_log = log.init_logging("ucf_serdes_constraints_generator")
if __name__ == "__main__":
    # initialize command line input
    opts, args = parse_options()

    # set verbosity according to option
    log.set_level(opts.verbosity)
    _log.debug ("*"*40)
    _log.info ("  UCF Serdes constraints generator")
    _log.info ("*"*40)
    _log.info ("Paste the following into your ucf file:")

    config_dict = VHDLConstantsParser.parse_vhdl_file(opts.files[0])
    quad_dict = get_quad_areagroup_mapping(opts.files[1])
    
    for key in sorted(config_dict):
        if "MU_QUAD_ASSIGNMENT" in key:
            for i in range(len(config_dict[key])):
                print generate_instance_string("MU", i, quad_dict[str(config_dict[key][i])])
        if "ENERGY_QUAD_ASSIGNMENT" in key:
            for i in range(len(config_dict[key])):
                print generate_instance_string("CALO", i, quad_dict[str(config_dict[key][i])])


def main():
    vhdl_dict = VHDLConstantsParser.parse_vhdl_file("data/ugmt_constants.vhd")

    opts = parse_options()
    fname_dict = discover_emu_files(opts.emudirectory)
    # rankLUT = l1t.MicroGMTRankPtQualLUT()

    for pattern, fnames in fname_dict.iteritems():
        print "+"*30, pattern, "+"*30
        events = Events(fnames['root'])

        start = time.time()

        tower_indices = None
        if 'idebug' in fnames.keys():
            debug_fname = fnames['idebug']
            with open(debug_fname, 'r') as fobj:
                tower_indices = [[int(idx.strip()) for idx in l.split()] for l in fobj]

        out_handle = Handle('BXVector<l1t::Muon>')
        imd_bmtf_handle = Handle('BXVector<l1t::Muon>')
        imd_emtf_p_handle = Handle('BXVector<l1t::Muon>')
        imd_emtf_n_handle = Handle('BXVector<l1t::Muon>')
        imd_omtf_p_handle = Handle('BXVector<l1t::Muon>')
        imd_omtf_n_handle = Handle('BXVector<l1t::Muon>')
        bar_handle = Handle('std::vector<l1t::L1TRegionalMuonCandidate>')
        fwd_handle = Handle('std::vector<l1t::L1TRegionalMuonCandidate>')
        ovl_handle = Handle('std::vector<l1t::L1TRegionalMuonCandidate>')
        calo_handle = Handle('std::vector<l1t::L1TGMTInputCaloSum>')

        basedir_testbench = "data/patterns/testbench/"
        basedir_mp7 = "data/patterns/mp7/"

        input_buffer = PatternDumper(basedir_mp7+pattern+".txt", vhdl_dict, BufferWriter)
        output_buffer = PatternDumper(basedir_mp7+pattern+"_out.txt", vhdl_dict, BufferWriter)
        input_testbench = PatternDumper(basedir_testbench+pattern+".txt", vhdl_dict, TestbenchWriter)
        serializer_testbench = PatternDumper(basedir_testbench+"serializer_"+pattern+".txt", vhdl_dict, TestbenchWriter)
        deserializer_testbench = PatternDumper(basedir_testbench+"deserializer_"+pattern+".txt", vhdl_dict, TestbenchWriter)
        integration_testbench = PatternDumper(basedir_testbench+"integration_"+pattern+".txt", vhdl_dict, TestbenchWriter)

        if opts.delay > 0:
            input_buffer.writeEmptyFrames(opts.delay)

        setup_time = time.time() - start

        avg_get_label_time = 0
        avg_conversion_time = 0
        avg_write_time = 0
        n_twrs = 0
        for i, event in enumerate(events):
            evt_start = time.time()
            event_head = "#"*80+"\n"
            event_head += "# Event: {ievent}\n".format(ievent=i)
            event_head += "#"*80+"\n"
            input_testbench.addLine(event_head)
            serializer_testbench.addLine(event_head)
            deserializer_testbench.addLine(event_head)
            integration_testbench.addLine(event_head)

            event.getByLabel("microGMTEmulator", out_handle)
            event.getByLabel("microGMTEmulator", "imdMuonsBMTF", imd_bmtf_handle)
            event.getByLabel("microGMTEmulator", "imdMuonsEMTFPos", imd_emtf_p_handle)
            event.getByLabel("microGMTEmulator", "imdMuonsEMTFNeg", imd_emtf_n_handle)
            event.getByLabel("microGMTEmulator", "imdMuonsOMTFPos", imd_omtf_p_handle)
            event.getByLabel("microGMTEmulator", "imdMuonsOMTFNeg", imd_omtf_n_handle)
            event.getByLabel("uGMTInputProducer", "BarrelTFMuons", bar_handle)
            event.getByLabel("uGMTInputProducer", "ForwardTFMuons", fwd_handle)
            event.getByLabel("uGMTInputProducer", "OverlapTFMuons", ovl_handle)

            event.getByLabel("uGMTInputProducer", "TriggerTowerSums", calo_handle)
            get_label_time = time.time() - evt_start
            calo_sums_raw = calo_handle.product()
            calo_sums = get_calo_list(calo_sums_raw)

            emu_out_muons = out_handle.product()
            outmuons = get_muon_list_out(emu_out_muons, "OUT", vhdl_dict)
            imd_emtf_p_prod = imd_emtf_p_handle.product()
            imdmuons = get_muon_list_out(imd_emtf_p_prod, "IMD", vhdl_dict, 4)
            imd_omtf_p_prod = imd_omtf_p_handle.product()
            imdmuons += get_muon_list_out(imd_omtf_p_prod, "IMD", vhdl_dict, 4)
            imd_bmtf_prod = imd_bmtf_handle.product()
            imdmuons += get_muon_list_out(imd_bmtf_prod, "IMD", vhdl_dict, 8)
            imd_omtf_n_prod = imd_omtf_n_handle.product()
            imdmuons += get_muon_list_out(imd_omtf_n_prod, "IMD", vhdl_dict, 4)
            imd_emtf_n_prod = imd_emtf_n_handle.product()
            imdmuons += get_muon_list_out(imd_emtf_n_prod, "IMD", vhdl_dict, 4)

            emu_bar_muons = bar_handle.product()
            bar_muons = get_muon_list(emu_bar_muons, "BMTF", vhdl_dict, i)
            emu_ovl_muons = ovl_handle.product()
            ovlp_muons = get_muon_list(emu_ovl_muons, "OMTF_POS", vhdl_dict, i)
            ovln_muons = get_muon_list(emu_ovl_muons, "OMTF_NEG", vhdl_dict, i)
            emu_fwd_muons = fwd_handle.product()
            fwdp_muons = get_muon_list(emu_fwd_muons, "EMTF_POS", vhdl_dict, i)
            fwdn_muons = get_muon_list(emu_fwd_muons, "EMTF_NEG", vhdl_dict, i)

            conversion_time = time.time() - evt_start - get_label_time
            input_buffer.writeFrameBasedInputBX(bar_muons, fwdp_muons, fwdn_muons, ovlp_muons, ovln_muons, calo_sums)
            integration_testbench.writeFrameBasedInputBX(bar_muons, fwdp_muons, fwdn_muons, ovlp_muons, ovln_muons, calo_sums)
            deserializer_testbench.writeFrameBasedInputBX(bar_muons, fwdp_muons, fwdn_muons, ovlp_muons, ovln_muons, calo_sums)
            output_buffer.writeFrameBasedOutputBX(outmuons, imdmuons)

            input_testbench.writeMuonBasedInputBX(bar_muons, fwdp_muons, fwdn_muons, ovlp_muons, ovln_muons, calosums=calo_sums, addTracks=True)
            input_testbench.addLine("# Expected emulator output\n")
            input_testbench.writeMuonBasedOutputBX(outmuons, imdmuons)
            deserializer_testbench.addLine("# Expected emulator output\n")
            deserializer_testbench.writeMuonBasedInputBX(bar_muons, fwdp_muons, fwdn_muons, ovlp_muons, ovln_muons, calosums=calo_sums, addTracks=True)
            if tower_indices is not None:
                input_testbench.addLine("# Tower indices:\n")
                cntr = 0
                for mu in outmuons:
                    if mu.bitword != 0:
                        cntr += 1
                input_testbench.writeTowerIndices(tower_indices[n_twrs:n_twrs+cntr])
                n_twrs += cntr

            serializer_testbench.writeMuonBasedOutputBX(outmuons, imdmuons)
            serializer_testbench.addLine("# Expected emulator output\n")
            serializer_testbench.writeFrameBasedOutputBX(outmuons, imdmuons)
            integration_testbench.addLine("# Expected emulator output\n")
            integration_testbench.writeFrameBasedOutputBX(outmuons, imdmuons)
            write_time = time.time() - evt_start - conversion_time
            avg_get_label_time += get_label_time
            avg_conversion_time += conversion_time
            avg_write_time += write_time
        print "total: ", time.time() - start
        print "setup: ", setup_time
        print "get_label:", "avg", avg_get_label_time/float(i+1), "last", get_label_time
        print "conversion: avg", avg_conversion_time/float(i+1), "last", conversion_time
        print "write: avg", avg_write_time/float(i+1), "last", write_time
        output_buffer.dump(True)
        input_testbench.dump()
        serializer_testbench.dump()
        deserializer_testbench.dump()
        input_buffer.dump()
        integration_testbench.dump()
def main():
    vhdl_dict = VHDLConstantsParser.parse_vhdl_file("../data/ugmt_constants.vhd")

    opts = parse_options()
    fname_dict = discover_emu_files(opts.emudirectory)
    # rankLUT = l1t.MicroGMTRankPtQualLUT()

    ALGODELAY = opts.delay + 25 #first frame with valid = 1

    max_events = int((1024-ALGODELAY)/6)

    for pattern, fnames in fname_dict.iteritems():
        print "+"*30, pattern, "+"*30
        events = Events(fnames['root'])

        start = time.time()

        out_handle = Handle('BXVector<l1t::Muon>')
        imd_bmtf_handle = Handle('BXVector<l1t::Muon>')
        imd_emtf_p_handle = Handle('BXVector<l1t::Muon>')
        imd_emtf_n_handle = Handle('BXVector<l1t::Muon>')
        imd_omtf_p_handle = Handle('BXVector<l1t::Muon>')
        imd_omtf_n_handle = Handle('BXVector<l1t::Muon>')
        bar_handle = Handle('BXVector<l1t::RegionalMuonCand>')
        fwd_handle = Handle('BXVector<l1t::RegionalMuonCand>')
        ovl_handle = Handle('BXVector<l1t::RegionalMuonCand>')
        calo_handle = Handle('BXVector<l1t::MuonCaloSum>')

        basedir_mp7 = "../data/patterns/compressed/"
        path = '{path}/{pattern}/'.format(path=basedir_mp7, pattern=pattern)

        input_buffer = PatternDumper(basedir_mp7+pattern+".txt", vhdl_dict, BufferWriter)
        output_buffer = PatternDumper(basedir_mp7+pattern+"_out.txt", vhdl_dict, BufferWriter)

        if opts.delay > 0:
            input_buffer.writeEmptyFrames(opts.delay)

        setup_time = time.time() - start

        avg_get_label_time = 0
        avg_conversion_time = 0
        avg_write_time = 0

        output_buffer.writeEmptyFrames(ALGODELAY)
        cntr = 0
        for i, event in enumerate(events):
            evt_start = time.time()
            event.getByLabel("simGmtStage2Digis", out_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsBMTF", imd_bmtf_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsEMTFPos", imd_emtf_p_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsEMTFNeg", imd_emtf_n_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsOMTFPos", imd_omtf_p_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsOMTFNeg", imd_omtf_n_handle)
            #event.getByLabel("simBmtfDigis", "BMTF", bar_handle)
            #event.getByLabel("simEmtfDigis", "EMTF", fwd_handle)
            #event.getByLabel("simOmtfDigis", "OMTF", ovl_handle)
            event.getByLabel("gmtStage2Digis", "BMTF", bar_handle)
            event.getByLabel("gmtStage2Digis", "EMTF", fwd_handle)
            event.getByLabel("gmtStage2Digis", "OMTF", ovl_handle)

            #event.getByLabel("simGmtCaloSumDigis", "TriggerTowerSums", calo_handle)
            event.getByLabel("emptyCaloCollsProducer", "EmptyTriggerTowerSums", calo_handle)
            #event.getByLabel("simGmtCaloSumDigis", "TriggerTower2x2s", calo_handle)
            get_label_time = time.time() - evt_start
            calo_sums_raw = calo_handle.product()
            calo_sums = get_calo_list(calo_sums_raw)

            emu_out_muons = out_handle.product()
            outmuons = get_muon_list_out(emu_out_muons, "OUT", vhdl_dict)
            imd_emtf_p_prod = imd_emtf_p_handle.product()
            imdmuons = get_muon_list_out(imd_emtf_p_prod, "IMD", vhdl_dict, 4)
            imd_omtf_p_prod = imd_omtf_p_handle.product()
            imdmuons += get_muon_list_out(imd_omtf_p_prod, "IMD", vhdl_dict, 4)
            imd_bmtf_prod = imd_bmtf_handle.product()
            imdmuons += get_muon_list_out(imd_bmtf_prod, "IMD", vhdl_dict, 8)
            imd_omtf_n_prod = imd_omtf_n_handle.product()
            imdmuons += get_muon_list_out(imd_omtf_n_prod, "IMD", vhdl_dict, 4)
            imd_emtf_n_prod = imd_emtf_n_handle.product()
            imdmuons += get_muon_list_out(imd_emtf_n_prod, "IMD", vhdl_dict, 4)

            emu_bar_muons = bar_handle.product()
            bar_muons = get_muon_list(emu_bar_muons, "BMTF", vhdl_dict, i)
            emu_ovl_muons = ovl_handle.product()
            ovlp_muons = get_muon_list(emu_ovl_muons, "OMTF_POS", vhdl_dict, i)
            ovln_muons = get_muon_list(emu_ovl_muons, "OMTF_NEG", vhdl_dict, i)
            emu_fwd_muons = fwd_handle.product()
            fwdp_muons = get_muon_list(emu_fwd_muons, "EMTF_POS", vhdl_dict, i)
            fwdn_muons = get_muon_list(emu_fwd_muons, "EMTF_NEG", vhdl_dict, i)

            conversion_time = time.time() - evt_start - get_label_time

            for mu in outmuons:
                if mu.bitword != 0:
                    cntr += 1
            input_buffer.writeFrameBasedInputBX(bar_muons, fwdp_muons, fwdn_muons, ovlp_muons, ovln_muons, calo_sums)
            output_buffer.writeFrameBasedOutputBX(outmuons, imdmuons)

            if i%(max_events-1) == 0 and i != 0: # dump every max_events
                ifile = i/max_events
                print "Writing file {pattern}_{ifile}.zip for event {i}".format(pattern=pattern, ifile=ifile, i=i)
                dump_files(path, pattern, ifile, input_buffer, output_buffer, opts.delay, ALGODELAY)


            if (i+1)%1000 == 0:
                print "  processing the {i}th event".format(i=i+1)

            write_time = time.time() - evt_start - conversion_time
            avg_get_label_time += get_label_time
            avg_conversion_time += conversion_time
            avg_write_time += write_time
        print "total: ", time.time() - start
        print "setup: ", setup_time
        print "get_label:", "avg", avg_get_label_time/float(i+1), "last", get_label_time
        print "conversion: avg", avg_conversion_time/float(i+1), "last", conversion_time
        print "write: avg", avg_write_time/float(i+1), "last", write_time
        print 'n final muons: ', cntr
        if i%(max_events-1) != 0:
            ifile = i/max_events
            dump_files(path, pattern, ifile, input_buffer, output_buffer, opts.delay, ALGODELAY)

        print (i+1)/max_events
Esempio n. 12
0
def main():
    vhdl_dict = VHDLConstantsParser.parse_vhdl_file(
        "../data/ugmt_constants.vhd")

    opts = parse_options()
    nSkip = opts.skip
    fname_dict = discover_emu_files(opts.emudirectory)
    # rankLUT = l1t.MicroGMTRankPtQualLUT()

    ALGODELAY = opts.delay + 27  #first frame with valid = 1

    max_events = int((1024 - ALGODELAY) / 6)

    for pattern, fnames in fname_dict.iteritems():
        print "+" * 30, pattern, "+" * 30
        events = Events(fnames['root'])

        start = time.time()

        out_handle = Handle('BXVector<l1t::Muon>')
        imd_bmtf_handle = Handle('BXVector<l1t::Muon>')
        imd_emtf_p_handle = Handle('BXVector<l1t::Muon>')
        imd_emtf_n_handle = Handle('BXVector<l1t::Muon>')
        imd_omtf_p_handle = Handle('BXVector<l1t::Muon>')
        imd_omtf_n_handle = Handle('BXVector<l1t::Muon>')
        bar_handle = Handle('BXVector<l1t::RegionalMuonCand>')
        fwd_handle = Handle('BXVector<l1t::RegionalMuonCand>')
        ovl_handle = Handle('BXVector<l1t::RegionalMuonCand>')
        calo_handle = Handle('BXVector<l1t::MuonCaloSum>')

        basedir_mp7 = "../data/patterns/compressed/"
        path = '{path}/{pattern}/'.format(path=basedir_mp7, pattern=pattern)

        input_buffer = PatternDumper(path + pattern + ".txt", vhdl_dict,
                                     BufferWriter)
        output_buffer = PatternDumper(path + pattern + "_out.txt", vhdl_dict,
                                      BufferWriter)

        if opts.delay > 0:
            input_buffer.writeEmptyFrames(opts.delay)

        setup_time = time.time() - start

        avg_get_label_time = 0
        avg_conversion_time = 0
        avg_write_time = 0

        output_buffer.writeEmptyFrames(ALGODELAY)
        cntr = 0
        for i, event in enumerate(events):
            if i < nSkip:
                continue

            #print 'event: {evt} {evNr}'.format(evt=i, evNr=event.eventAuxiliary().event())

            evt_start = time.time()
            event.getByLabel("simGmtStage2Digis", out_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsBMTF",
                             imd_bmtf_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsEMTFPos",
                             imd_emtf_p_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsEMTFNeg",
                             imd_emtf_n_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsOMTFPos",
                             imd_omtf_p_handle)
            event.getByLabel("simGmtStage2Digis", "imdMuonsOMTFNeg",
                             imd_omtf_n_handle)
            event.getByLabel("simBmtfDigis", "BMTF", bar_handle)
            event.getByLabel("simEmtfDigis", "EMTF", fwd_handle)
            event.getByLabel("simOmtfDigis", "OMTF", ovl_handle)
            #event.getByLabel("gmtStage2Digis", "BMTF", bar_handle)
            #event.getByLabel("gmtStage2Digis", "EMTF", fwd_handle)
            #event.getByLabel("gmtStage2Digis", "OMTF", ovl_handle)

            event.getByLabel("simGmtCaloSumDigis", "TriggerTowerSums",
                             calo_handle)
            #event.getByLabel("emptyCaloCollsProducer", "EmptyTriggerTowerSums", calo_handle)
            #event.getByLabel("simGmtCaloSumDigis", "TriggerTower2x2s", calo_handle)
            get_label_time = time.time() - evt_start
            calo_sums_raw = calo_handle.product()
            calo_sums = get_calo_list(calo_sums_raw)

            emu_out_muons = out_handle.product()
            outmuons = get_muon_list_out(emu_out_muons, "OUT", vhdl_dict)
            imd_emtf_p_prod = imd_emtf_p_handle.product()
            imdmuons = get_muon_list_out(imd_emtf_p_prod, "IMD", vhdl_dict, 4)
            imd_omtf_p_prod = imd_omtf_p_handle.product()
            imdmuons += get_muon_list_out(imd_omtf_p_prod, "IMD", vhdl_dict, 4)
            imd_bmtf_prod = imd_bmtf_handle.product()
            imdmuons += get_muon_list_out(imd_bmtf_prod, "IMD", vhdl_dict, 8)
            imd_omtf_n_prod = imd_omtf_n_handle.product()
            imdmuons += get_muon_list_out(imd_omtf_n_prod, "IMD", vhdl_dict, 4)
            imd_emtf_n_prod = imd_emtf_n_handle.product()
            imdmuons += get_muon_list_out(imd_emtf_n_prod, "IMD", vhdl_dict, 4)

            emu_bar_muons = bar_handle.product()
            bar_muons = get_muon_list(emu_bar_muons, "BMTF", vhdl_dict, i)
            emu_ovl_muons = ovl_handle.product()
            ovlp_muons = get_muon_list(emu_ovl_muons, "OMTF_POS", vhdl_dict, i)
            ovln_muons = get_muon_list(emu_ovl_muons, "OMTF_NEG", vhdl_dict, i)
            emu_fwd_muons = fwd_handle.product()
            fwdp_muons = get_muon_list(emu_fwd_muons, "EMTF_POS", vhdl_dict, i)
            fwdn_muons = get_muon_list(emu_fwd_muons, "EMTF_NEG", vhdl_dict, i)

            conversion_time = time.time() - evt_start - get_label_time

            for mu in outmuons:
                if mu.bitword != 0:
                    cntr += 1
            input_buffer.writeFrameBasedInputBX(bar_muons, fwdp_muons,
                                                fwdn_muons, ovlp_muons,
                                                ovln_muons, calo_sums)
            output_buffer.writeFrameBasedOutputBX(outmuons, imdmuons)

            if i % (max_events - 1) == 0 and i != 0:  # dump every max_events
                ifile = i / max_events
                print "Writing file {pattern}_{ifile}.zip for event {i}".format(
                    pattern=pattern, ifile=ifile, i=i)
                dump_files(path, pattern, ifile, input_buffer, output_buffer,
                           opts.delay, ALGODELAY)

            if (i + 1) % 1000 == 0:
                print "  processing the {i}th event".format(i=i + 1)

            write_time = time.time() - evt_start - conversion_time
            avg_get_label_time += get_label_time
            avg_conversion_time += conversion_time
            avg_write_time += write_time
        print "total: ", time.time() - start
        print "setup: ", setup_time
        print "get_label:", "avg", avg_get_label_time / float(
            i + 1), "last", get_label_time
        print "conversion: avg", avg_conversion_time / float(
            i + 1), "last", conversion_time
        print "write: avg", avg_write_time / float(i + 1), "last", write_time
        print 'n final muons: ', cntr
        if i % (max_events - 1) != 0:
            ifile = i / max_events
            dump_files(path, pattern, ifile, input_buffer, output_buffer,
                       opts.delay, ALGODELAY)

        print(i + 1) / max_events
Esempio n. 13
0
def main():
    vhdl_dict = VHDLConstantsParser.parse_vhdl_file("../data/ugmt_constants.vhd")

    opts = parse_options()
    fname_dict = discover_emu_files(opts.emudirectory)

    ALGODELAY = 60 #first frame with valid = 1

    max_events = int((1024-ALGODELAY)/6)

    for pattern, fnames in fname_dict.iteritems():

        print "+"*30, pattern, "+"*30
        events = Events(fnames['root'])

        out_handle = Handle('BXVector<l1t::Muon>')
        imd_handle = Handle('BXVector<l1t::Muon>')
        bar_handle = Handle('std::vector<l1t::L1TRegionalMuonCandidate>')
        fwd_handle = Handle('std::vector<l1t::L1TRegionalMuonCandidate>')
        ovl_handle = Handle('std::vector<l1t::L1TRegionalMuonCandidate>')

        calo_handle = Handle('std::vector<l1t::L1TGMTInputCaloSum>')

        basedir_mp7 = "patterns/compressed/"
        path = '{path}/{pattern}/'.format(path=basedir_mp7, pattern=pattern)

        input_buffer = PatternDumper(basedir_mp7+pattern+".txt", vhdl_dict, BufferWriter)
        output_buffer = PatternDumper(basedir_mp7+pattern+"_out.txt", vhdl_dict, BufferWriter)

        if opts.delay > 0:
            input_buffer.writeEmptyFrames(opts.delay)

        output_buffer.writeEmptyFrames(ALGODELAY)
        cntr = 0
        for i, event in enumerate(events):
            event.getByLabel("microGMTEmulator", out_handle)
            event.getByLabel("microGMTEmulator", "intermediateMuons", imd_handle)
            event.getByLabel("uGMTInputProducer", "BarrelTFMuons", bar_handle)
            event.getByLabel("uGMTInputProducer", "ForwardTFMuons", fwd_handle)
            event.getByLabel("uGMTInputProducer", "OverlapTFMuons", ovl_handle)

            event.getByLabel("uGMTInputProducer", "TriggerTowerSums", calo_handle)

            calo_sums_raw = calo_handle.product()
            calo_sums = get_calo_list(calo_sums_raw)

            emu_out_muons = out_handle.product()
            outmuons = get_muon_list_out(emu_out_muons, "OUT", vhdl_dict)
            imd_prod = imd_handle.product()
            imdmuons = get_muon_list_out(imd_prod, "IMD", vhdl_dict)
            emu_bar_muons = bar_handle.product()
            bar_muons = get_muon_list(emu_bar_muons, "BMTF", vhdl_dict)
            emu_ovl_muons = ovl_handle.product()
            ovlp_muons = get_muon_list(emu_ovl_muons, "OMTF_POS", vhdl_dict)
            ovln_muons = get_muon_list(emu_ovl_muons, "OMTF_NEG", vhdl_dict)
            emu_fwd_muons = fwd_handle.product()
            fwdp_muons = get_muon_list(emu_fwd_muons, "EMTF_POS", vhdl_dict)
            fwdn_muons = get_muon_list(emu_fwd_muons, "EMTF_NEG", vhdl_dict)
            for mu in outmuons:
                if mu.bitword != 0: cntr += 1
            input_buffer.writeFrameBasedInputBX(bar_muons, fwdp_muons, fwdn_muons, ovlp_muons, ovln_muons, calo_sums)
            output_buffer.writeFrameBasedOutputBX(outmuons, imdmuons)

            if i%(max_events-1) == 0 and i != 0: # dump every max_events
                ifile = i/max_events
                print "Writing file {pattern}_{ifile}.zip for event {i}".format(pattern=pattern, ifile=ifile, i=i)
                dump_files(path, pattern, ifile, input_buffer, output_buffer, opts.delay, ALGODELAY)


            if (i+1)%1000 == 0:
                print "  processing the {i}th event".format(i=i+1)
        print 'n final muons: ', cntr
        if i%(max_events-1) != 0:
            ifile = i/max_events
            dump_files(path, pattern, ifile, input_buffer, output_buffer, opts.delay, ALGODELAY)

        print (i+1)/max_events