RPCLBPacker.cc

Go to the documentation of this file.

#include "EventFilter/RPCRawToDigi/interface/RPCLBPacker.h"

#include "FWCore/Utilities/interface/Exception.h"

#include "CondFormats/RPCObjects/interface/RPCInverseLBLinkMap.h"
#include "DataFormats/RPCDigi/interface/RPCDigi.h"

void RPCLBPacker::getRPCLBRecords(RPCInverseLBLinkMap const & lb_map
                                  , int min_bx, int max_bx, unsigned int bcn
                                  , RPCDigiCollection const & digis
                                  , std::map<RPCLBLink, std::vector<std::pair<int, RPCLBRecord> > > & mlb_bx_lbrecord
                                  , bool ignore_eod)
{
    if (max_bx - min_bx >= 128 || min_bx < -3564) { // limit 7 bits RPCLBRecord BCN; avoid overflow
        throw cms::Exception("RPCLBPacker")
            << "Out-of-range input for min_bx, max_bx (" << min_bx << ": " << max_bx << ")";
    }

    std::map<RPCLBLink, std::vector<RPCLBRecord> > mlb_lbrecords;

    // digi to record ; setBCN to (bx - min_bx) for easy sorting (avoid -1 = 3563 > 0)
    RPCDigiCollection::DigiRangeIterator digi_range_end(digis.end());
    for (RPCDigiCollection::DigiRangeIterator digi_range = digis.begin()
             ; digi_range != digi_range_end ; ++digi_range) {
        RPCDigiCollection::DigiRangeIterator::value_type digi_range_value(*digi_range);
        std::pair<RPCInverseLBLinkMap::map_type::const_iterator
                  , RPCInverseLBLinkMap::map_type::const_iterator> lookup_range(lb_map.getMap().equal_range(digi_range_value.first.rawId()));

        for (RPCDigiCollection::const_iterator digi = digi_range_value.second.first
                 ; digi != digi_range_value.second.second ; ++digi) {
            if (digi->bx() < min_bx || digi->bx() > max_bx) {
                continue;
            }

            for (RPCInverseLBLinkMap::map_type::const_iterator link_it = lookup_range.first
                     ; link_it != lookup_range.second ; ++link_it) {
                if (link_it->second.second.hasStrip(digi->strip())) {
                    unsigned int channel(link_it->second.second.getChannel(digi->strip()));
                    RPCLBLink lb_link(link_it->second.first);
                    RPCLBLink mlb_link(lb_link);
                    mlb_link.setLinkBoard().setConnector();
                    mlb_lbrecords[mlb_link].push_back(RPCLBRecord(digi->bx() - min_bx, false
                                                                  , lb_link.getLinkBoard(), false, 0, lb_link.getConnector()
                                                                  , (channel > 8 ? 1 : 0), 0x01 << ((channel - 1) % 8) ));
                    break;
                }
            }
        }
    }

    // merge records, set correct bcn and delay, and EOD if necessary
    for (std::map<RPCLBLink, std::vector<RPCLBRecord> >::iterator mlb_lbrecords_it = mlb_lbrecords.begin()
             ; mlb_lbrecords_it != mlb_lbrecords.end() ; ++mlb_lbrecords_it) {
        std::vector<RPCLBRecord> & input(mlb_lbrecords_it->second);
        std::sort(input.begin(), input.end());

        std::vector<std::pair<int, RPCLBRecord> > bx_lbrecord;
        bx_lbrecord.reserve(input.size());

        RPCLBRecord last_lbrecord(input.front()); // it's not empty by construction
        unsigned int idx(0);
        for (std::vector<RPCLBRecord>::const_iterator input_it = input.begin() + 1
                 ; input_it <= input.end() ; ++input_it) {
            if (input_it != input.end()
                && ((last_lbrecord.getRecord() & ~RPCLBRecord::partition_data_mask_)
                    == (input_it->getRecord() & ~RPCLBRecord::partition_data_mask_))) {
                last_lbrecord.set(last_lbrecord.getRecord() | input_it->getRecord());
            } else {
                unsigned int last_bcn(last_lbrecord.getBCN());
                if (last_bcn > idx) {
                    idx = last_bcn;
                }
                unsigned int delay(idx - last_bcn);
                if (ignore_eod && delay == 8) {
                    --idx;
                    --delay;
                    bx_lbrecord.back().second.setEOD(true);
                    last_lbrecord.setEOD(true);
                }
                if (delay < 8) {
                    last_lbrecord.setDelay(delay);
                    last_bcn = (3564 + bcn + min_bx + idx) % 3564;
                    last_lbrecord.setBCN(last_bcn);
                    last_lbrecord.setBC0(last_bcn == 0);
                    bx_lbrecord.push_back(std::pair<int, RPCLBRecord>(min_bx + idx, last_lbrecord));
                    ++idx;
                } else {
                    bx_lbrecord.back().second.setEOD(true);
                }
                if (input_it != input.end()) {
                    last_lbrecord = *input_it;
                }
            }
        }

        mlb_bx_lbrecord.insert(std::map<RPCLBLink
                               , std::vector<std::pair<int, RPCLBRecord> > >::value_type(mlb_lbrecords_it->first
                                                                                         , bx_lbrecord));
    }
}