GlobalAlgBlkUnpacker.cc

Go to the documentation of this file.

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "EventFilter/L1TRawToDigi/plugins/UnpackerFactory.h"

#include "GTCollections.h"
#include "GlobalAlgBlkUnpacker.h"

namespace l1t {
namespace stage2 {
   bool
   GlobalAlgBlkUnpacker::unpack(const Block& block, UnpackerCollections *coll)
   {

     LogDebug("L1T") << "AMCNo " << block.amc().getAMCNumber() << " Block ID  = " << block.header().getID() << " size = " << block.header().getSize();

    // ================================================================================
    //Should this be configured someplace?
     unsigned int wdPerBX      = 6;
     unsigned int initialBlkID = 33; //first block of inital alg bits 
     unsigned int intermBlkID  = 39; //first block of alg bits after intermediate step
     unsigned int finalBlkID   = 45; //first block of final alg bits
    // ================================================================================ 
     
     
     unsigned int uGTBoard = block.amc().getAMCNumber() - 1;

      
     int nBX = int(ceil(block.header().getSize() / 6.)); // FOR GT Not sure what we have here...put at 6 because of 6 frames 

     // Find the central, first and last BXs
     int firstBX = -(ceil((double)nBX/2.)-1);
     int lastBX;
     if (nBX % 2 == 0) {
       lastBX = ceil((double)nBX/2.);
     } else {
       lastBX = ceil((double)nBX/2.)-1;
     }

     auto res_ = static_cast<GTCollections*>(coll)->getAlgs();
     res_->setBXRange(firstBX, lastBX);

     LogDebug("L1T")  << "nBX = " << nBX << " first BX = " << firstBX << " lastBX = " << lastBX  << endl;

     // Loop over multiple BX and then number of EG cands filling collection
     int numBX = 0;  //positive int to count BX
     for (int bx=firstBX; bx<=lastBX; bx++){

       
        // If this is the first block on first board, instantiate GlobalAlg so it is there to fill from mult. blocks
       if(block.header().getID()==initialBlkID && uGTBoard == 0 ) {

      LogDebug("L1T") << "Creating GT Algorithm Block for BX =" << bx << std::endl;
          GlobalAlgBlk talg = GlobalAlgBlk();
          res_->push_back(bx,talg);

       }

       //fetch
       GlobalAlgBlk alg = res_->at(bx,0);

       //Determine offset of algorithm bits based on block.ID
       // ID=initialBlkID    offset = 0;  ID=initialBlkID+2    offset=192;  ID=initialBlkID+4    offset=384=2*192; (before prescale)
       // ID=intermBlkID  offset = 0;  ID=intermBlkID+2  offset=192;  ID=intermBlkID+4  offset=384=2*192; (after prescale)
       // ID=finalBlkID      offset = 0;  ID=finalBlkID+2      offset=192;  ID=finalBlkID+4      offset=384=2*192; (after mask (Final))
       int algOffset = (block.header().getID() - initialBlkID + 1)/2;
       algOffset = (algOffset%3)*192;

       for(unsigned int wd=0;  wd<wdPerBX; wd++) {
         uint32_t raw_data = block.payload()[wd+numBX*wdPerBX];
     LogDebug("L1T") << "BX "<<bx << " payload word " << wd << " 0x" << hex << raw_data << " offset=" << dec << algOffset  << std::endl;

         //parse these 32 bits into algorithm bits (perhaps needs a more efficient way of doing this?
         if( (block.header().getID()!=initialBlkID+4 && block.header().getID()!=intermBlkID+4 && block.header().getID()!=finalBlkID+4 ) || wd<4) {
           for(unsigned int bt=0; bt<32; bt++) {
         int val = ((raw_data >> bt) & 0x1);
         unsigned int algBit = bt+wd*32+algOffset;
         
         if(val==1 && algBit < alg.maxPhysicsTriggers) { 
            LogDebug("L1T") << "Found valid alg bit ("<< algBit <<") on bit ("<<bt<<") word ("<<wd<<") algOffset ("<<algOffset<<") block ID ("<< block.header().getID() <<")" << " Board# " << uGTBoard <<std::endl;
            if(block.header().getID()<initialBlkID+5) {
          alg.setAlgoDecisionInitial(algBit,true);
        } else if(block.header().getID()<intermBlkID+5) {  
          alg.setAlgoDecisionInterm(algBit,true);
        } else {  
          alg.setAlgoDecisionFinal(algBit,true);
        }  
         } else if(val==1) {
             LogDebug("L1T") << "Found invalid alg bit ("<< algBit <<") out of range on bit ("<<bt<<") word ("<<wd<<") algOffset ("<<algOffset<<") block ID ("<< block.header().getID() <<")" <<std::endl;
         }
           }
       
     } else if(block.header().getID()==initialBlkID+4 && (wd==4 || wd==5) ) {
       //This is the 32bit hash of menu name
       if(wd==4) alg.setL1MenuUUID(raw_data);  
           //This is the 32bit hash of menu firmware uuid
       if(wd==5) alg.setL1FirmwareUUID(raw_data);   
          
     } else if(block.header().getID()==finalBlkID+4 && wd==4) {
           //Get the local FINORs and Veto...Global FINOR calculated below
       if ( (raw_data &   0x100)>> 8 ) alg.setFinalORVeto(true);
       if ( (raw_data &     0x1)>> 0 ) alg.setFinalORPreVeto(true);
           LogDebug("L1T")  << " Packing the FinalOR " << wd << " 0x" << hex << raw_data << endl;   
     } else if(block.header().getID()==finalBlkID+4 && wd==5) {
           //This is the Prescale Column
           alg.setPreScColumn(raw_data & 0xFF );
           LogDebug("L1T")  << " Packing the Prescale Column " << wd << " 0x" << hex << raw_data << endl;   
         }
       }

       //Redetermine Final (multiboard)  FINOR
       if(alg.getFinalORPreVeto() & !alg.getFinalORVeto()) {
          alg.setFinalOR(true);  
       } else {
          alg.setFinalOR(false); //be explicit and must set to false if we find a board with veto set.
       }

       // Put the object back into place (Must be better way)
       res_->set(bx,0,alg);

       //alg.print(std::cout);
       
       //increment counter of which BX we are processing
       numBX++; 
     }

     return true;
   }
}
}

DEFINE_L1T_UNPACKER(l1t::stage2::GlobalAlgBlkUnpacker);