TrigMuonRoITool Class Reference

#include <TrigMuonRoITool.h>

Inheritance diagram for TrigMuonRoITool:

Collaboration diagram for TrigMuonRoITool:

Public Member Functions
	TrigMuonRoITool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual std::unique_ptr< TrigMuonRoITool::MuonRois >	decodeMuCTPi (const EventContext &ctx) const override
	Decoding the muCTPi RoIB and DAQ ROB and return in and out of time RoIs. More...

Private Types
typedef ServiceHandle< IROBDataProviderSvc >	IIROBDataProviderSvc_t

Private Member Functions
uint32_t	mirodToRoIBDataWord (uint32_t data_word) const
	Helper for converting a mirod DAQ data word to a muCTPi RoIB data word. More...
void	dumpRoIBDataWord (uint32_t data_word) const
	Helper to print contents of a muCTPi RoIB data word. More...

Private Attributes
SG::ReadHandleKey< MuCTPI_RDO >	m_muCTPIKey {this, "MUCTPILocation", "MUCTPI_RDO", "Location of MUCTPI RDO"}
IIROBDataProviderSvc_t	m_robDataProviderSvc
	Reference to the ROBDataProviderSvc service. More...
IntegerProperty	m_daqMuCTPiROBid
	Source identifiers for ROB fragments. More...
std::vector< uint32_t >	m_muCTPiRobIds
	vectors with muCTPi ROB Ids to retrieve More...
bool	m_decodeMuCTPiFromROB
	Configurable to decide how to decode muCTPi. More...

Static Private Attributes
static const uint32_t	NUMBER_OF_PT_THRESHOLDS = 6
	Number of pt Thresholds. More...

Detailed Description

Definition at line 16 of file TrigMuonRoITool.h.

Member Typedef Documentation

IIROBDataProviderSvc_t

typedef ServiceHandle<IROBDataProviderSvc> TrigMuonRoITool::IIROBDataProviderSvc_t

private

Definition at line 34 of file TrigMuonRoITool.h.

Constructor & Destructor Documentation

TrigMuonRoITool()

TrigMuonRoITool::TrigMuonRoITool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 12 of file TrigMuonRoITool.cxx.

                                           : 
  base_class(type,name,parent),
  m_robDataProviderSvc( "ROBDataProviderSvc", name ),
  m_decodeMuCTPiFromROB(false)
{
  // Declare the properties
  declareProperty("DaqMuCTPiROBid",m_daqMuCTPiROBid=0x760000);
  declareProperty("DecodeMuCTPiFromROB",m_decodeMuCTPiFromROB=false);
}

Member Function Documentation

decodeMuCTPi()

std::unique_ptr< TrigMuonRoITool::MuonRois > TrigMuonRoITool::decodeMuCTPi ( const EventContext &  ctx ) const

overridevirtual

Decoding the muCTPi RoIB and DAQ ROB and return in and out of time RoIs.

helper to decode MuCTPi information

Definition at line 45 of file TrigMuonRoITool.cxx.

                                                                                                  {
 
  // save input stream flags
  char log_fill_char_save = (msg().stream()).fill();
 
 
  // decode MUCTPI
 
  // MuCTPi pointer
  const MuCTPI_RDO* daqmuCTPIResult = 0;
  
  // Build muCTPi from DAQ ROB
  if(m_decodeMuCTPiFromROB) {
  
    // in L2 the DAQ muCTPi ROB needs to be retreived first from the ROS
    m_robDataProviderSvc->addROBData(ctx, m_muCTPiRobIds);
 
    // get the muCTPi ROB fragment
    std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> muCTPiRobFragmentVec;
    muCTPiRobFragmentVec.reserve(m_muCTPiRobIds.size());
    m_robDataProviderSvc->getROBData(ctx, m_muCTPiRobIds,muCTPiRobFragmentVec);
    
    if (muCTPiRobFragmentVec.size()==0) {
      ATH_MSG_DEBUG(" decodeMuCTPi: No muCTPi ROB found.");
      return nullptr;
    }
      
    // check for received ROB id and return if it doesn't match the DAQ MuCTPI ROB
    ATH_MSG_DEBUG(" decodeMuCTPi: ROB id = 0x" << std::setw(6)  << MSG::hex << muCTPiRobFragmentVec[0]->source_id() << MSG::dec);
    
    if (muCTPiRobFragmentVec[0]->source_id() != (uint32_t)m_daqMuCTPiROBid.value()) {
      ATH_MSG_DEBUG(" decodeMuCTPi: received ROB id = 0x" << std::setw(6) << MSG::hex << muCTPiRobFragmentVec[0]->source_id() << MSG::dec
            << " does not match requested ROB id = 0x"
            << std::setw(6) << MSG::hex << m_daqMuCTPiROBid.value() << MSG::dec);
      return nullptr; 
    }
    
    // decode now the ROB
    uint32_t formatVersion = muCTPiRobFragmentVec[0]->rod_version();
    uint32_t evtNum        = muCTPiRobFragmentVec[0]->rod_lvl1_id();
    uint32_t robFragSize   = muCTPiRobFragmentVec[0]->fragment_size_word();
    uint32_t rodFragSize   = muCTPiRobFragmentVec[0]->rod_fragment_size_word();
    uint32_t robId         = muCTPiRobFragmentVec[0]->source_id();
    uint32_t rodId         = muCTPiRobFragmentVec[0]->rod_source_id();
    const uint32_t bcId    = muCTPiRobFragmentVec[0]->rod_bc_id();
    
    const uint32_t* status;
    muCTPiRobFragmentVec[0]->rod_status( status );
    // nstatus, errorStat not used, cause compilation warning
    //uint32_t nstatus = muCTPiRobFragmentVec[0]->rod_nstatus();
    //uint32_t errorStat( 0 );
    //if( nstatus > 0 ) errorStat = static_cast< uint32_t >( *status );
    //
    
    ATH_MSG_DEBUG("ROB ID 0x" << MSG::hex << robId <<  " ROD ID 0x"
          << rodId << MSG::dec << " ROB fragment size "
          << robFragSize << " ROD fragment size " << rodFragSize);
            
    ATH_MSG_DEBUG(" ROD Header L1 ID " << evtNum
          << " ROD Header BCID " << bcId
          << " ROD Header Format version " << formatVersion);
    
    OFFLINE_FRAGMENTS_NAMESPACE::PointerType it_data;
    muCTPiRobFragmentVec[0]->rod_data( it_data );
    const uint32_t ndata = muCTPiRobFragmentVec[0]->rod_ndata();
    ATH_MSG_DEBUG( " Dumping RoI Words:");
    ATH_MSG_DEBUG( " number of data words: " << ndata);
    // candidate multiplicity
    std::vector< uint32_t > candidateMultiplicity;
    // data words
    std::vector< uint32_t > dataWord;
    for( uint32_t i = 0; i < ndata; ++i, ++it_data ) {
      if( *it_data >> LVL1::MuCTPIBits::MULT_WORD_FLAG_SHIFT ) {
    candidateMultiplicity.push_back( static_cast< uint32_t >( *it_data ) );
    ATH_MSG_DEBUG("     0x" << MSG::hex << std::setw( 8 ) << std::setfill( '0' )
              << ( *it_data ) << " (candidate multiplicity)" << std::setfill( log_fill_char_save ));
      } else {
    dataWord.push_back( static_cast< uint32_t >( *it_data ) );
    ATH_MSG_DEBUG("     0x" << MSG::hex << std::setw( 8 ) << std::setfill( '0' )
              << ( *it_data ) << " (candidate word)" 
              << " (--> RoI word = 0x" << MSG::hex << std::setw( 8 ) << std::setfill( '0' ) 
              << mirodToRoIBDataWord( *it_data ) << ")" 
              << std::setfill( log_fill_char_save ));
      }
    }
    
    // create MuCTPi RDO (DAQ  muCTPi Result)
    daqmuCTPIResult = new MuCTPI_RDO( std::move(candidateMultiplicity), std::move(dataWord) );
  }
  
  // Retrieve the MuCTPi RDO via data handle
  else{
    SG::ReadHandle<MuCTPI_RDO> rdoHandle(m_muCTPIKey, ctx);
    if(rdoHandle.isValid()){
    daqmuCTPIResult = rdoHandle.cptr();
      }
    else{
      ATH_MSG_WARNING("Can't get MUCTPI_RDO object");
      return nullptr;
    }
  }
  
  // print contents
  if (msgLvl(MSG::DEBUG)) {
    MuCTPI_MultiplicityWord_Decoder(daqmuCTPIResult->candidateMultiplicity()).dumpData(msg());
    for(std::vector< uint32_t >::const_iterator it = daqmuCTPIResult->dataWord().begin();
    it != daqmuCTPIResult->dataWord().end(); ++it) {
      MuCTPI_DataWord_Decoder(*it).dumpData(msg());
      dumpRoIBDataWord(mirodToRoIBDataWord(*it));
    }
  }
 
  // now select out the RoI candidates for the BCID which triggered the event and save them in 
  // a special list indexed by RoI ID
  uint16_t roiEventBCID = MuCTPI_MultiplicityWord_Decoder(daqmuCTPIResult->candidateMultiplicity()).getBCID();
  uint16_t roiEventNCan = MuCTPI_MultiplicityWord_Decoder(daqmuCTPIResult->candidateMultiplicity()).getNCandidates();
 
  // reset the containers and fill them with new data
  auto inTime_muCTPIRoIs= std::vector<ROIB::MuCTPIRoI>();
  auto outOfTime_muCTPIRoIs= std::vector< std::pair<ROIB::MuCTPIRoI,int> >();
 
  inTime_muCTPIRoIs.reserve( roiEventNCan );
  outOfTime_muCTPIRoIs.reserve( roiEventNCan );
 
  for(std::vector< uint32_t >::const_iterator it = daqmuCTPIResult->dataWord().begin();
      it != daqmuCTPIResult->dataWord().end(); ++it) {
 
    // decode the RDO data word
    MuCTPI_DataWord_Decoder daqRoI(*it);
 
    // create a L1 RoI
    ROIB::MuCTPIRoI roI( mirodToRoIBDataWord(*it) );
 
    if (roiEventBCID == daqRoI.getBCID()) { // RoI matches event BCID
      inTime_muCTPIRoIs.push_back(roI);
    } else {
      outOfTime_muCTPIRoIs.push_back( std::pair<ROIB::MuCTPIRoI,int>(roI,(int(daqRoI.getBCID())-int(roiEventBCID))) );
    }
  } // end loop over data words
  
  // print contents of RoI arrays
  if (msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG(" RoIs in time with event BCID:  Number of RoIs = " << inTime_muCTPIRoIs.size());
    for (std::vector< ROIB::MuCTPIRoI >::iterator it = inTime_muCTPIRoIs.begin(); it != inTime_muCTPIRoIs.end(); ++it) {
      dumpRoIBDataWord((*it).roIWord());
    }
 
    ATH_MSG_DEBUG(" RoIs out of time with event BCID:  Number of RoIs = " << outOfTime_muCTPIRoIs.size());
    for (std::vector< std::pair<ROIB::MuCTPIRoI,int> >::iterator it = outOfTime_muCTPIRoIs.begin(); it != outOfTime_muCTPIRoIs.end(); ++it) {
      ATH_MSG_DEBUG( " Difference(RoI(BCID) - Event(BCID)) = " << (*it).second);
      dumpRoIBDataWord(((*it).first).roIWord());
    }
  }
 
  std::unique_ptr<TrigMuonRoITool::MuonRois> rois(new TrigMuonRoITool::MuonRois(std::move(inTime_muCTPIRoIs), std::move(outOfTime_muCTPIRoIs)));
 
 
  if(m_decodeMuCTPiFromROB)
    delete daqmuCTPIResult;
 
  return rois; 
}

dumpRoIBDataWord()

void TrigMuonRoITool::dumpRoIBDataWord ( uint32_t  data_word ) const

private

Helper to print contents of a muCTPi RoIB data word.

Definition at line 219 of file TrigMuonRoITool.cxx.

                                                                 {
 
  ROIB::MuCTPIRoI roI(data_word);
 
  std::string loc = "UNDEFINED"; 
  if( roI.getSectorLocation() == MuCTPI_RDO::ENDCAP )
    loc = "ENDCAP";
  else if( roI.getSectorLocation() == MuCTPI_RDO::FORWARD )
    loc = "FORWARD";
  else if( roI.getSectorLocation() == MuCTPI_RDO::BARREL )
    loc = "BARREL";
 
  ATH_MSG_DEBUG( "RoIB word               : 0x" << MSG::hex << roI.roIWord() );
  ATH_MSG_DEBUG( "Threshold               :  pt" << roI.pt() );
  ATH_MSG_DEBUG( "Sector location         :  " << loc );
  std::string sectorOffset("");  
  if ((roI.getSectorAddress() & LVL1::MuCTPIBits::SECTOR_HEMISPHERE_MASK) &&
      (roI.getSectorLocation() == MuCTPI_RDO::BARREL)) sectorOffset = " + 32 for Hemisphere = 1 "; 
  ATH_MSG_DEBUG( "Sector ID               :  " << roI.getSectorID() << sectorOffset );
  ATH_MSG_DEBUG( "Sector addr             :  0x" << MSG::hex << roI.getSectorAddress());
  ATH_MSG_DEBUG( "Sector overflow         :  " << roI.getSectorOverflow() );
  ATH_MSG_DEBUG( "RoI overflow            :  " << roI.getRoiOverflow() );
  ATH_MSG_DEBUG( "RoI number              :  " << roI.getRoiNumber() );
  ATH_MSG_DEBUG( "IsHighestPt             :  " << roI.getCandidateIsHighestPt() );
  ATH_MSG_DEBUG( "Overlap                 :  " << roI.getOverlapBits() );
  ATH_MSG_DEBUG( "Hemisphere              :  " << (roI.getSectorAddress() & LVL1::MuCTPIBits::SECTOR_HEMISPHERE_MASK) );
  return;
}

initialize()

StatusCode TrigMuonRoITool::initialize ( )

overridevirtual

Definition at line 25 of file TrigMuonRoITool.cxx.

{
  ATH_CHECK( AthAlgTool::initialize() );
  ATH_CHECK( m_robDataProviderSvc.retrieve() );
 
  // Print the property values
  ATH_MSG_DEBUG(" ROB ID: DAQ muCTPi = " << m_daqMuCTPiROBid
        << std::setw(6) << " (=0x" << MSG::hex << m_daqMuCTPiROBid.value() << MSG::dec << ")");
 
  // Build the vector with ROB Ids to retrieve
  m_muCTPiRobIds.push_back(m_daqMuCTPiROBid.value());
 
  //Retrieve the MuCTPi RDO is we aren't decoding them ourselves
  ATH_CHECK(m_muCTPIKey.initialize(!m_decodeMuCTPiFromROB));
  
  return StatusCode::SUCCESS; 
}

mirodToRoIBDataWord()

uint32_t TrigMuonRoITool::mirodToRoIBDataWord ( uint32_t  data_word ) const

private

Helper for converting a mirod DAQ data word to a muCTPi RoIB data word.

Definition at line 213 of file TrigMuonRoITool.cxx.

                                                                        {
  return ( ( ( data_word & 0x8000000 ) >> 4 ) | ( ( data_word & 0x3fe0000 ) >> 3 ) |
       ( data_word & 0x3fff ) );
}

Member Data Documentation

m_daqMuCTPiROBid

IntegerProperty TrigMuonRoITool::m_daqMuCTPiROBid

private

Source identifiers for ROB fragments.

Definition at line 39 of file TrigMuonRoITool.h.

m_decodeMuCTPiFromROB

bool TrigMuonRoITool::m_decodeMuCTPiFromROB

private

Configurable to decide how to decode muCTPi.

Definition at line 54 of file TrigMuonRoITool.h.

m_muCTPIKey

SG::ReadHandleKey<MuCTPI_RDO> TrigMuonRoITool::m_muCTPIKey {this, "MUCTPILocation", "MUCTPI_RDO", "Location of MUCTPI RDO"}

private

Definition at line 32 of file TrigMuonRoITool.h.

m_muCTPiRobIds

std::vector<uint32_t> TrigMuonRoITool::m_muCTPiRobIds

private

vectors with muCTPi ROB Ids to retrieve

Definition at line 42 of file TrigMuonRoITool.h.

m_robDataProviderSvc

IIROBDataProviderSvc_t TrigMuonRoITool::m_robDataProviderSvc

private

Reference to the ROBDataProviderSvc service.

Definition at line 36 of file TrigMuonRoITool.h.

NUMBER_OF_PT_THRESHOLDS

const uint32_t TrigMuonRoITool::NUMBER_OF_PT_THRESHOLDS = 6

staticprivate

Number of pt Thresholds.

Definition at line 45 of file TrigMuonRoITool.h.

---

The documentation for this class was generated from the following files:

• TrigMuonRoITool.h
• TrigMuonRoITool.cxx