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()
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()
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()
imd_ranks = output_parser.get_ranks()
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()
imd_ranks = output_parser.get_ranks()
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
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
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
