SCTRawContByteStreamTool Class Reference

Athena Algorithm Tool to provide conversion from SCT RDO container to ByteStream. More...

#include <SCTRawContByteStreamTool.h>

Inheritance diagram for SCTRawContByteStreamTool:

Collaboration diagram for SCTRawContByteStreamTool:

Public Member Functions
	SCTRawContByteStreamTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual	~SCTRawContByteStreamTool ()=default
	Destructor.
virtual StatusCode	initialize () override
	Initialize.
virtual StatusCode	finalize () override
	Finalize.
virtual StatusCode	convert (const SCT_RDO_Container *sctRDOCont) const override
	Main Convert method.

Private Attributes
ServiceHandle< IByteStreamCnvSvc >	m_byteStreamCnvSvc { this, "ByteStreamCnvSvc", "ByteStreamCnvSvc" }
ToolHandle< ISCT_RodEncoder >	m_encoder {this, "Encoder", "SCT_RodEncoder", "SCT ROD Encoder for RDO to BS conversion"}
	Algorithm Tool to decode ROB bytestream data into RDO.
ToolHandle< ISCT_CablingTool >	m_cabling {this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"}
	Providing mappings of online and offline identifiers and also serial numbers.
const SCT_ID *	m_sctIDHelper {nullptr}
	Identifier helper class for the SCT subdetector that creates compact Identifier objects and IdentifierHash or hash IDs.
UnsignedShortProperty	m_rodBlockVersion {this, "RodBlockVersion", 0}

Detailed Description

Athena Algorithm Tool to provide conversion from SCT RDO container to ByteStream.

Conversion from SCT RDO container to ByteStream, and fill it in RawEvent.

The class inherits from AthAlgTool and ISCTRawContByteStreamTool.

Contains convert method that maps ROD ID's to vectors of RDOs in those RODs, then loops through the map, using RodEncoder to fill data for each ROD in turn.

Definition at line 37 of file SCTRawContByteStreamTool.h.

Constructor & Destructor Documentation

SCTRawContByteStreamTool()

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

Constructor.

Definition at line 18 of file SCTRawContByteStreamTool.cxx.

                                                                             :
  base_class(type, name, parent)
{
}

~SCTRawContByteStreamTool()

virtual SCTRawContByteStreamTool::~SCTRawContByteStreamTool ( )

virtualdefault

Destructor.

Member Function Documentation

convert()

StatusCode SCTRawContByteStreamTool::convert ( const SCT_RDO_Container * sctRDOCont ) const

overridevirtual

Main Convert method.

Maps ROD ID's to vectors of RDOs in those RODs, then loops through the map, using RodEncoder to fill data for each ROD in turn.

Parameters

sctRDOCont

SCT RDO Container of Raw Data Collections.

Definition at line 49 of file SCTRawContByteStreamTool.cxx.

{
  FullEventAssembler<SrcIdMap>* fullEventAssembler = nullptr;
  ATH_CHECK( m_byteStreamCnvSvc->getFullEventAssembler (fullEventAssembler,
                                                        "SCTRawCont") );
  FullEventAssembler<SrcIdMap>::RODDATA* rod;
  
  // Set ROD Minor version
  fullEventAssembler->setRodMinorVersion(m_rodBlockVersion);
  ATH_MSG_DEBUG(" Setting Minor Version Number to " << m_rodBlockVersion);
  
  // Mapping between ROD IDs and the hits in that ROD
  std::map<uint32_t, std::vector<const SCT_RDORawData*>> rdoMap;
 
  // The following few lines are to make sure there is an entry in the rdoMap for 
  // every ROD, even if there are no hits in it for a particular event 
  // (as there might be ByteStream errors e.g. TimeOut errors).
  std::vector<std::uint32_t> listOfAllRODs;
  m_cabling->getAllRods(listOfAllRODs);
  for (std::uint32_t rod : listOfAllRODs) {
    rdoMap[rod].clear();
  }
 
  // Loop over the collections in the SCT RDO container
  for (const InDetRawDataCollection<SCT_RDORawData>* sctRawColl : *sctRDOCont) {
    if (sctRawColl == nullptr) {
      ATH_MSG_WARNING("Null pointer to SCT RDO collection.");
      continue;
    } 
    else {
      // Collection ID
      Identifier idColl{sctRawColl->identify()};
      IdentifierHash idCollHash{m_sctIDHelper->wafer_hash(idColl)};
      uint32_t robid{m_cabling->getRobIdFromHash(idCollHash)};
      
      if (robid == 0) continue;
      
      // Building the ROD ID
      eformat::helper::SourceIdentifier srcIDROB{robid};
      eformat::helper::SourceIdentifier srcIDROD{srcIDROB.subdetector_id(), srcIDROB.module_id()};
      uint32_t rodid{srcIDROD.code()};
      
      // Loop over RDOs in the collection
      for (const SCT_RDORawData* rdo : *sctRawColl) {
        // Fill the ROD/RDO map
        rdoMap[rodid].push_back(rdo);
      }
    }
  }  // End loop over collections
 
  // Now encode data for each ROD in turn
  for (const auto& rodToRDOs : rdoMap) {
    rod = fullEventAssembler->getRodData(rodToRDOs.first); // Get ROD data address
    m_encoder->fillROD(*rod, rodToRDOs.first, rodToRDOs.second); // Encode ROD data
  }
  
  return StatusCode::SUCCESS;
}

finalize()

StatusCode SCTRawContByteStreamTool::finalize ( )

overridevirtual

Finalize.

Definition at line 42 of file SCTRawContByteStreamTool.cxx.

{
  return StatusCode::SUCCESS;
}

initialize()

StatusCode SCTRawContByteStreamTool::initialize ( )

overridevirtual

Initialize.

Definition at line 26 of file SCTRawContByteStreamTool.cxx.

{
  ATH_CHECK( m_byteStreamCnvSvc.retrieve() );
 
  // Retrieve ID mapping
  ATH_CHECK(m_cabling.retrieve());
  ATH_MSG_INFO("Retrieved service " << m_cabling);
 
  // Get the SCT Helper
  ATH_CHECK(detStore()->retrieve(m_sctIDHelper, "SCT_ID"));
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_byteStreamCnvSvc

ServiceHandle<IByteStreamCnvSvc> SCTRawContByteStreamTool::m_byteStreamCnvSvc { this, "ByteStreamCnvSvc", "ByteStreamCnvSvc" }

private

Definition at line 64 of file SCTRawContByteStreamTool.h.

{ this, "ByteStreamCnvSvc", "ByteStreamCnvSvc" };

m_cabling

ToolHandle<ISCT_CablingTool> SCTRawContByteStreamTool::m_cabling {this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"}

private

Providing mappings of online and offline identifiers and also serial numbers.

Definition at line 71 of file SCTRawContByteStreamTool.h.

{this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"};

m_encoder

ToolHandle<ISCT_RodEncoder> SCTRawContByteStreamTool::m_encoder {this, "Encoder", "SCT_RodEncoder", "SCT ROD Encoder for RDO to BS conversion"}

private

Algorithm Tool to decode ROB bytestream data into RDO.

Definition at line 68 of file SCTRawContByteStreamTool.h.

{this, "Encoder", "SCT_RodEncoder", "SCT ROD Encoder for RDO to BS conversion"};

m_rodBlockVersion

UnsignedShortProperty SCTRawContByteStreamTool::m_rodBlockVersion {this, "RodBlockVersion", 0}

private

Definition at line 77 of file SCTRawContByteStreamTool.h.

{this, "RodBlockVersion", 0};

m_sctIDHelper

const SCT_ID* SCTRawContByteStreamTool::m_sctIDHelper {nullptr}

private

Identifier helper class for the SCT subdetector that creates compact Identifier objects and IdentifierHash or hash IDs.

Also allows decoding of these IDs.

Definition at line 75 of file SCTRawContByteStreamTool.h.

{nullptr};

---

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

• SCTRawContByteStreamTool.h
• SCTRawContByteStreamTool.cxx