# check if the match was not perfect
            mismatch = rel_in < Relation.max_relation or rel_imd < Relation.max_relation
            # check if BX is the same... as a few bits were usually not fitting
            mismatch_bx = mu_in == None or mu_imd == None or mu_in.bx != mu_out.bx or mu_imd.bx != mu_out.bx

            # first dump the matches with some additional info:
            if (mismatch_bx or (mismatch and options.verbose) or options.detaildump):
                print "+"*30, "BX", mu_out.bx, "+"*30
                print "out: ", print_out_word(mu_out.bitword), "in BX", mu_out.bx, "( frame:", mu_out.frame, " link:", mu_out.link, ")"
                if mu_imd != None:
                    print "imd: ", print_out_word(mu_imd.bitword), "in BX", mu_imd.bx, "( frame:", mu_imd.frame, " link:", mu_imd.link, \
                        " match: {match:.2%} )".format(match=rel_imd/float(Relation.max_relation))
                else: 
                    print "imd: NO MATCH"
                if mu_in != None:
                    print "in : ", print_in_word(mu_in.bitword), "in BX", mu_in.bx, "( frame:", mu_in.frame, " link:", mu_in.link, \
                        " match: {match:.2%} )".format(match=rel_in/float(Relation.max_relation))
                else:
                    print "in : NO MATCH"

            # Now, dump details about the BXs that were connected above (if options.verbose --> option -v)
            if options.verbose and mismatch and mu_in != None and mu_imd != None:
                bxs = [mu_out.bx]
                if not mu_in.bx in bxs: bxs.append(mu_in.bx)
                if not mu_imd.bx in bxs: bxs.append(mu_imd.bx)
                print "BX dumps:"

                for bx in bxs:
                    print "BX ", bx
                    print "-"*30 + "non-zero in muons: -" + "-"*30
                    for iinmu in xrange(bx*108, (bx+1)*108):
Example #2
0
            mismatch_bx = mu_in == None or mu_imd == None or mu_in.bx != mu_out.bx or mu_imd.bx != mu_out.bx

            # first dump the matches with some additional info:
            if (mismatch_bx or (mismatch and options.verbose)
                    or options.detaildump):
                print "+" * 30, "BX", mu_out.bx, "+" * 30
                print "out: ", print_out_word(
                    mu_out.bitword
                ), "in BX", mu_out.bx, "( frame:", mu_out.frame, " link:", mu_out.link, ")"
                if mu_imd != None:
                    print "imd: ", print_out_word(mu_imd.bitword), "in BX", mu_imd.bx, "( frame:", mu_imd.frame, " link:", mu_imd.link, \
                        " match: {match:.2%} )".format(match=rel_imd/float(Relation.max_relation))
                else:
                    print "imd: NO MATCH"
                if mu_in != None:
                    print "in : ", print_in_word(mu_in.bitword), "in BX", mu_in.bx, "( frame:", mu_in.frame, " link:", mu_in.link, \
                        " match: {match:.2%} )".format(match=rel_in/float(Relation.max_relation))
                else:
                    print "in : NO MATCH"

            # Now, dump details about the BXs that were connected above (if options.verbose --> option -v)
            if options.verbose and mismatch and mu_in != None and mu_imd != None:
                bxs = [mu_out.bx]
                if not mu_in.bx in bxs: bxs.append(mu_in.bx)
                if not mu_imd.bx in bxs: bxs.append(mu_imd.bx)
                print "BX dumps:"

                for bx in bxs:
                    print "BX ", bx
                    print "-" * 30 + "non-zero in muons: -" + "-" * 30
                    for iinmu in xrange(bx * 108, (bx + 1) * 108):
    for pattern, fnames in file_dict.iteritems():
        version = Version.from_filename(fnames['base'])
        print "+"*30, "version detected:", version, "+"*30
        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()

        for mu in in_muons:
            if mu.bitword != 0:
                if mu.qualityBits == 2:
                    _log.debug(print_in_word(mu.bitword))
                    _log.debug(hex(mu.bitword))
        out_muons = output_parser.get_output_muons()
        intermediate_muons = output_parser.get_intermediate_muons()
        ranks = output_parser.get_ranks()
        #### here the number of nonzero ranks is counted
        rank_num_of_non_zeros = 0
        for i in xrange(len(ranks)):
            if ranks[i]!=0:
                rank_num_of_non_zeros = rank_num_of_non_zeros+1
        ####

        _log.info("in_muons : {nz} / {all}".format(nz=non_zero(in_muons), all=len(in_muons)))
        _log.info("num of final non-zero Output-Muons: {nz} / {all}".format(nz=non_zero(out_muons), all=len(out_muons)))#,"), corresponds to ", len(out_muons)/8," Events")
        _log.info("num of intermediate non-zero Output-Muons: {nz} / {all}".format(nz=non_zero(intermediate_muons), all=len(intermediate_muons)))#, "), corresponds to ", len(intermediate_muons)/24," Events" )
        _log.info("n_ranks {nz} / {all}".format(nz=rank_num_of_non_zeros, all=len(ranks)))
    for pattern, fnames in file_dict.iteritems():
        version = Version.from_filename(fnames['base'])
        print "+" * 30, "version detected:", version, "+" * 30
        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()

        for mu in in_muons:
            if mu.bitword != 0:
                if mu.qualityBits == 2:
                    _log.debug(print_in_word(mu.bitword))
                    _log.debug(hex(mu.bitword))
        out_muons = output_parser.get_output_muons()
        intermediate_muons = output_parser.get_intermediate_muons()
        ranks = output_parser.get_ranks()
        #### here the number of nonzero ranks is counted
        rank_num_of_non_zeros = 0
        for i in xrange(len(ranks)):
            if ranks[i] != 0:
                rank_num_of_non_zeros = rank_num_of_non_zeros + 1
        ####

        _log.info("in_muons : {nz} / {all}".format(nz=non_zero(in_muons),
                                                   all=len(in_muons)))
        _log.info("num of final non-zero Output-Muons: {nz} / {all}".format(
            nz=non_zero(out_muons), all=len(out_muons))
Example #5
0
            non_zero_emu = [mu for mu in emu_in_muons if mu.bitword != 0]

        if emu_in_muons is not None:
            mu_to_print = {}
            if options.verbose:
                mu_to_print = zip(in_muons, emu_in_muons)
            else:
                mu_to_print = zip(non_zero, non_zero_emu)

            last_bx = 0
            for mu, mu_emu in mu_to_print:
                if mu.bx != last_bx:
                    print "*" * 50, "current bx:", mu.bx, mu_emu.bx, "*" * 50
                    last_bx = mu.bx
                if options.verbose or (mu.bitword != mu_emu.bitword):
                    print "hw", print_in_word(
                        mu.bitword), "emu", print_in_word(mu_emu.bitword)
        else:
            mu_to_print = []
            if options.verbose:
                mu_to_print = in_muons
            else:
                mu_to_print = non_zero

            last_bx = 0
            for mu in non_zero:
                if mu.bx != last_bx:
                    print "*" * 50, "current bx:", mu.bx, "*" * 50
                    last_bx = mu.bx

                print print_in_word(mu.bitword)
            non_zero_emu = [ mu for mu in emu_in_muons if mu.bitword != 0 ]


        if emu_in_muons is not None:
            mu_to_print = {}
            if options.verbose:
                mu_to_print = zip(in_muons, emu_in_muons)
            else:
                mu_to_print = zip(non_zero, non_zero_emu)

            last_bx = 0
            for mu, mu_emu in mu_to_print:
                if mu.bx != last_bx:
                    print "*"*50, "current bx:", mu.bx, mu_emu.bx, "*"*50
                    last_bx = mu.bx
                if options.verbose or (mu.bitword != mu_emu.bitword):
                    print "hw", print_in_word(mu.bitword), "emu", print_in_word(mu_emu.bitword)
        else:
            mu_to_print = []
            if options.verbose:
                mu_to_print = in_muons
            else:
                mu_to_print = non_zero

            last_bx = 0            
            for mu in non_zero:
                if mu.bx != last_bx:
                    print "*"*50, "current bx:", mu.bx, "*"*50
                    last_bx = mu.bx

                print print_in_word(mu.bitword)