xAODSpacePointMaker Class Reference

Creates xAOD space point containers from FPGA input and existing clusters. More...

#include <xAODSpacePointMaker.h>

Inheritance diagram for xAODSpacePointMaker:

Collaboration diagram for xAODSpacePointMaker:

Public Member Functions
StatusCode	initialize () override
	Initialise the space point maker tool.
StatusCode	makePixelSpacePointContainer (const EFTrackingTransient::SpacePointAuxInput &spAux, const EFTrackingTransient::Metadata *metadata, const EventContext &ctx) const
	Make the pixel space point container.
StatusCode	makeStripSpacePointContainer (const EFTrackingTransient::SpacePointAuxInput &sspAux, const EFTrackingTransient::Metadata *metadata, const EventContext &ctx) const
	Make the strip space point container.

Private Attributes
SG::ReadHandleKey< xAOD::PixelClusterContainer >	m_pixelClusterKey
	Key for the pixel cluster container to read from.
SG::ReadHandleKey< xAOD::StripClusterContainer >	m_stripClusterKey
	Key for the strip cluster container to read from.
SG::WriteHandleKey< xAOD::SpacePointContainer >	m_pixelSpacePointsKey
	Key for the pixel space points container to be created.
SG::WriteHandleKey< xAOD::SpacePointContainer >	m_stripSpacePointsKey
	Key for the strip space points container to be created.

Detailed Description

Creates xAOD space point containers from FPGA input and existing clusters.

Definition at line 33 of file xAODSpacePointMaker.h.

Member Function Documentation

initialize()

StatusCode xAODSpacePointMaker::initialize ( )

override

Initialise the space point maker tool.

Definition at line 20 of file xAODSpacePointMaker.cxx.

                                           {
  ATH_MSG_INFO("Initialising xAODSpacePointMaker tool");
 
  ATH_CHECK(m_pixelClusterKey.initialize());
  ATH_CHECK(m_stripClusterKey.initialize());
  
  ATH_CHECK(m_pixelSpacePointsKey.initialize());
  ATH_CHECK(m_stripSpacePointsKey.initialize());
 
  return StatusCode::SUCCESS;
}

makePixelSpacePointContainer()

StatusCode xAODSpacePointMaker::makePixelSpacePointContainer	(	const EFTrackingTransient::SpacePointAuxInput &	spAux,
		const EFTrackingTransient::Metadata *	metadata,
		const EventContext &	ctx ) const

Make the pixel space point container.

Parameters

spAux	Input space point data
metadata	Input metadata
ctx

Returns

StatusCode

Definition at line 32 of file xAODSpacePointMaker.cxx.

                                   {
    
    if (msgLvl(MSG::DEBUG)) {
        ATH_MSG_DEBUG("Making xAOD::SpacePointContainer from SpacePointAuxInput");
        
        // debugging information about vector sizes
        ATH_MSG_DEBUG("Metadata numOfPixelSpacePoints: " << metadata->numOfPixelSpacePoints);
        ATH_MSG_DEBUG("spAux.elementIdList size: " << spAux.elementIdList.size());
        ATH_MSG_DEBUG("spAux.globalPosition size: " << spAux.globalPosition.size());
        ATH_MSG_DEBUG("spAux.measurementIndexes size: " << spAux.measurementIndexes.size());
        ATH_MSG_DEBUG("spAux.varianceR size: " << spAux.varianceR.size());
        ATH_MSG_DEBUG("spAux.varianceZ size: " << spAux.varianceZ.size());
    }
 
    // Check for inconsistent metadata and throw an error if it is
    if (metadata->numOfPixelSpacePoints > 0 && 
        (spAux.elementIdList.empty() || 
         spAux.globalPosition.empty() || 
         spAux.measurementIndexes.empty() ||
         spAux.varianceR.empty() ||
         spAux.varianceZ.empty())) {
        ATH_MSG_WARNING("Inconsistent metadata: numOfPixelSpacePoints = " 
                     << metadata->numOfPixelSpacePoints 
                     << " but one or more required vectors are empty");
        return StatusCode::SUCCESS;
    }
 
    if (metadata->numOfPixelSpacePoints > 0 && spAux.elementIdList.empty()) {
        ATH_MSG_WARNING("Inconsistent metadata!");
    }
 
    // Create the containers
    SG::WriteHandle<xAOD::SpacePointContainer> pixelSpacePointsHandle(m_pixelSpacePointsKey, ctx);
    ATH_CHECK(pixelSpacePointsHandle.record(
        std::make_unique<xAOD::SpacePointContainer>(),
        std::make_unique<xAOD::SpacePointAuxContainer>()));
    
    ATH_CHECK(pixelSpacePointsHandle.isValid());
    ATH_MSG_DEBUG("Container '" << m_pixelSpacePointsKey << "' initialised");
 
    // Get pixel cluster container for linking
    SG::ReadHandle<xAOD::PixelClusterContainer> pixelClusters(m_pixelClusterKey, ctx);
    if (!pixelClusters.isValid()) {
        ATH_MSG_ERROR("Could not retrieve pixel cluster container");
        return StatusCode::FAILURE;
    }
 
    // Create spacepoints
    for (unsigned int i = 0; i < metadata->numOfPixelSpacePoints; i++) {
        // Add bounds checking for all vector accesses
        if (i >= spAux.elementIdList.size()) {
            ATH_MSG_ERROR("Index out of bounds: i=" << i 
                         << " >= elementIdList.size()=" << spAux.elementIdList.size());
            return StatusCode::FAILURE;
        }
        
        if (i >= spAux.varianceR.size()) {
            ATH_MSG_ERROR("Index out of bounds: i=" << i 
                         << " >= varianceR.size()=" << spAux.varianceR.size());
            return StatusCode::FAILURE;
        }
        
        if (i >= spAux.varianceZ.size()) {
            ATH_MSG_ERROR("Index out of bounds: i=" << i 
                         << " >= varianceZ.size()=" << spAux.varianceZ.size());
            return StatusCode::FAILURE;
        }
        
        if (i >= spAux.measurementIndexes.size()) {
            ATH_MSG_ERROR("Index out of bounds: i=" << i 
                         << " >= measurementIndexes.size()=" << spAux.measurementIndexes.size());
            return StatusCode::FAILURE;
        }
        
        if (i*3+2 >= spAux.globalPosition.size()) {
            ATH_MSG_ERROR("Index out of bounds: i*3+2=" << (i*3+2) 
                         << " >= globalPosition.size()=" << spAux.globalPosition.size());
            return StatusCode::FAILURE;
        }
 
        // use unique_ptr to avoid memory leak
        auto sp = pixelSpacePointsHandle->push_back(std::make_unique<xAOD::SpacePoint>());
 
        // Create position vector
        Eigen::Matrix<float, 3, 1> globalPosition(
            spAux.globalPosition.at(i * 3),
            spAux.globalPosition.at(i * 3 + 1),
            spAux.globalPosition.at(i * 3 + 2));
 
        // Get the measurement index
        const int measIdx = spAux.measurementIndexes.at(i);
 
        // Create the spacepoint with empty measurements vector
        sp->setSpacePoint(
            spAux.elementIdList[i],
            globalPosition,
            spAux.varianceR[i],
            spAux.varianceZ[i],
            std::vector<const xAOD::UncalibratedMeasurement*>()); // Empty vector
 
        // Create ElementLink to the pixel cluster
        if (measIdx >= 0 && static_cast<size_t>(measIdx) < pixelClusters->size()) {
            ElementLink<xAOD::PixelClusterContainer> link(*pixelClusters, measIdx);
            static const SG::Decorator<ElementLink<xAOD::PixelClusterContainer>> dec("fpgaPixelClusterLink");
            dec(*sp) = link;
        }
    }
 
    // After creating all spacepoints print the number of spacepoints created in debug stream
    ATH_MSG_DEBUG("Created " << pixelSpacePointsHandle->size() << " pixel spacepoints");
 
    return StatusCode::SUCCESS;
}

makeStripSpacePointContainer()

StatusCode xAODSpacePointMaker::makeStripSpacePointContainer	(	const EFTrackingTransient::SpacePointAuxInput &	sspAux,
		const EFTrackingTransient::Metadata *	metadata,
		const EventContext &	ctx ) const

Make the strip space point container.

Parameters

sspAux	Input space point data
metadata	Input metadata
ctx

Returns

StatusCode

Definition at line 149 of file xAODSpacePointMaker.cxx.

                                   {
    ATH_MSG_DEBUG("Making xAOD::SpacePointContainer from SpacePointAuxInput");
    
    // debug stream for information about vector sizes
    ATH_MSG_DEBUG("Metadata numOfStripSpacePoints: " << metadata->numOfStripSpacePoints);
    ATH_MSG_DEBUG("sspAux.elementIdList size: " << sspAux.elementIdList.size());
    ATH_MSG_DEBUG("sspAux.globalPosition size: " << sspAux.globalPosition.size());
    ATH_MSG_DEBUG("sspAux.measurementIndexes size: " << sspAux.measurementIndexes.size());
    ATH_MSG_DEBUG("sspAux.varianceR size: " << sspAux.varianceR.size());
    ATH_MSG_DEBUG("sspAux.varianceZ size: " << sspAux.varianceZ.size());
 
    // Check for inconsistent metadata and throw an error if it is
    if (metadata->numOfStripSpacePoints > 0 && 
        (sspAux.elementIdList.empty() || 
         sspAux.globalPosition.empty() || 
         sspAux.measurementIndexes.empty() ||
         sspAux.varianceR.empty() ||
         sspAux.varianceZ.empty())) {
        ATH_MSG_ERROR("Inconsistent metadata: numOfStripSpacePoints = " 
                     << metadata->numOfStripSpacePoints 
                     << " but one or more required vectors are empty");
        return StatusCode::FAILURE;
    }
 
    if (metadata->numOfStripSpacePoints > 0 && sspAux.elementIdList.empty()) {
        ATH_MSG_WARNING("Inconsistent metadata!");
    }
 
    // create the containers
    SG::WriteHandle<xAOD::SpacePointContainer> stripSpacePointsHandle(m_stripSpacePointsKey, ctx);
    ATH_CHECK(stripSpacePointsHandle.record(
        std::make_unique<xAOD::SpacePointContainer>(),
        std::make_unique<xAOD::SpacePointAuxContainer>()));
    
    ATH_CHECK(stripSpacePointsHandle.isValid());
    ATH_MSG_DEBUG("Container '" << m_stripSpacePointsKey << "' initialised");
 
    // get the strip cluster container for linking
    SG::ReadHandle<xAOD::StripClusterContainer> stripClusters(m_stripClusterKey, ctx);
    if (!stripClusters.isValid()) {
        ATH_MSG_ERROR("Could not retrieve strip cluster container");
        return StatusCode::FAILURE;
    }
 
    // create the spacepoints
    for (unsigned int i = 0; i < metadata->numOfStripSpacePoints; i++) {
        // add bounds checking for all vector accesses
        if (i >= sspAux.elementIdList.size()) {
            ATH_MSG_ERROR("Index out of bounds: i=" << i 
                         << " >= elementIdList.size()=" << sspAux.elementIdList.size());
            return StatusCode::FAILURE;
        }
        
        if (i >= sspAux.varianceR.size()) {
            ATH_MSG_ERROR("Index out of bounds: i=" << i 
                         << " >= varianceR.size()=" << sspAux.varianceR.size());
            return StatusCode::FAILURE;
        }
        
        if (i >= sspAux.varianceZ.size()) {
            ATH_MSG_ERROR("Index out of bounds: i=" << i 
                         << " >= varianceZ.size()=" << sspAux.varianceZ.size());
            return StatusCode::FAILURE;
        }
        
        if (i*2+1 >= sspAux.measurementIndexes.size()) {
            ATH_MSG_ERROR("Index out of bounds: i*2+1=" << (i*2+1) 
                         << " >= measurementIndexes.size()=" << sspAux.measurementIndexes.size());
            return StatusCode::FAILURE;
        }
        
        if (i*3+2 >= sspAux.globalPosition.size()) {
            ATH_MSG_ERROR("Index out of bounds: i*3+2=" << (i*3+2) 
                         << " >= globalPosition.size()=" << sspAux.globalPosition.size());
            return StatusCode::FAILURE;
        }
 
        // use unique_ptr here to avoid any memory leaks
        auto ssp = stripSpacePointsHandle->push_back(std::make_unique<xAOD::SpacePoint>());
 
        // Create position vector
        Eigen::Matrix<float, 3, 1> globalPosition(
            sspAux.globalPosition.at(i * 3),
            sspAux.globalPosition.at(i * 3 + 1),
            sspAux.globalPosition.at(i * 3 + 2));
 
        // Get the measurement index
        const int meas_idx1 = sspAux.measurementIndexes.at(i * 2);
        const int meas_idx2 = sspAux.measurementIndexes.at(i * 2 + 1);
 
        // For strip spacepoints, we need to use the version with two element IDs!
        std::vector<xAOD::DetectorIDHashType> elementIds;
        elementIds.push_back(sspAux.elementIdList.at(i * 2));
        elementIds.push_back(sspAux.elementIdList.at(i * 2 + 1));
        
        
        // Get strip-specific properties
        float topHalfStripLength = 0.0f;
        float bottomHalfStripLength = 0.0f;
        
        if (i < sspAux.topHalfStripLength.size()) {
            topHalfStripLength = sspAux.topHalfStripLength.at(i);
        }
        
        if (i < sspAux.bottomHalfStripLength.size()) {
            bottomHalfStripLength = sspAux.bottomHalfStripLength.at(i);
        }
        
        // Create direction vectors
        Eigen::Matrix<float, 3, 1> topStripDirection = Eigen::Matrix<float, 3, 1>::Zero();
        if (i * 3 + 2 < sspAux.topStripDirection.size()) {
            topStripDirection = Eigen::Matrix<float, 3, 1>(
                sspAux.topStripDirection.at(i * 3),
                sspAux.topStripDirection.at(i * 3 + 1),
                sspAux.topStripDirection.at(i * 3 + 2));
        }
        
        Eigen::Matrix<float, 3, 1> bottomStripDirection = Eigen::Matrix<float, 3, 1>::Zero();
        if (i * 3 + 2 < sspAux.bottomStripDirection.size()) {
            bottomStripDirection = Eigen::Matrix<float, 3, 1>(
                sspAux.bottomStripDirection.at(i * 3),
                sspAux.bottomStripDirection.at(i * 3 + 1),
                sspAux.bottomStripDirection.at(i * 3 + 2));
        }
        
        Eigen::Matrix<float, 3, 1> stripCenterDistance = Eigen::Matrix<float, 3, 1>::Zero();
        if (i * 3 + 2 < sspAux.stripCenterDistance.size()) {
            stripCenterDistance = Eigen::Matrix<float, 3, 1>(
                sspAux.stripCenterDistance.at(i * 3),
                sspAux.stripCenterDistance.at(i * 3 + 1),
                sspAux.stripCenterDistance.at(i * 3 + 2));
        }
        
        Eigen::Matrix<float, 3, 1> topStripCenter = Eigen::Matrix<float, 3, 1>::Zero();
        if (i * 3 + 2 < sspAux.topStripCenter.size()) {
            topStripCenter = Eigen::Matrix<float, 3, 1>(
                sspAux.topStripCenter.at(i * 3),
                sspAux.topStripCenter.at(i * 3 + 1),
                sspAux.topStripCenter.at(i * 3 + 2));
        }
        
        // Create the spacepoint with all required parameters
        ssp->setSpacePoint(
            std::move(elementIds),
            globalPosition, 
            sspAux.varianceR.at(i), 
            sspAux.varianceZ.at(i),
            std::vector<const xAOD::UncalibratedMeasurement*>(),  // Empty vector of strip measurements
            topHalfStripLength,
            bottomHalfStripLength,
            topStripDirection,
            bottomStripDirection,
            stripCenterDistance,
            topStripCenter);
 
        // Instead of storing measurements directly, store ElementLinks
        if (meas_idx1 >= 0 && static_cast<size_t>(meas_idx1) < stripClusters->size() &&
            meas_idx2 >= 0 && static_cast<size_t>(meas_idx2) < stripClusters->size()) {
            
            // Create ElementLinks to the strip clusters
            ElementLink<xAOD::StripClusterContainer> link1(*stripClusters, meas_idx1);
            ElementLink<xAOD::StripClusterContainer> link2(*stripClusters, meas_idx2);
            
            // Store the links as auxiliary data
            static const SG::Decorator<ElementLink<xAOD::StripClusterContainer>> dec1("fpgaStripClusterLink1");
            static const SG::Decorator<ElementLink<xAOD::StripClusterContainer>> dec2("fpgaStripClusterLink2");
            dec1(*ssp) = link1;
            dec2(*ssp) = link2;
        }
 
        // set the global position of the space point
        ssp->globalPosition() = globalPosition;
 
        // validate the position of the space point
        ATH_MSG_DEBUG("Strip Spacepoint " << i << " position: (" 
                     << globalPosition(0) << ", "
                     << globalPosition(1) << ", "
                     << globalPosition(2) << ")");
    }
    
    ATH_MSG_DEBUG("Created " << stripSpacePointsHandle->size() << " strip spacepoints");
    
    return StatusCode::SUCCESS;
} 

Member Data Documentation

m_pixelClusterKey

SG::ReadHandleKey<xAOD::PixelClusterContainer> xAODSpacePointMaker::m_pixelClusterKey

private

Initial value:

{
      this, "PixelClusterContainerKey", "FPGAPixelClusters",
      "Key for input pixel cluster container"}

Key for the pixel cluster container to read from.

Definition at line 68 of file xAODSpacePointMaker.h.

                                                              {
      this, "PixelClusterContainerKey", "FPGAPixelClusters",
      "Key for input pixel cluster container"};

m_pixelSpacePointsKey

SG::WriteHandleKey<xAOD::SpacePointContainer> xAODSpacePointMaker::m_pixelSpacePointsKey

private

Initial value:

{
      this, "PixelSpacePointContainerKey", "FPGAPixelSpacePoints",
      "Key for output pixel space point container"}

Key for the pixel space points container to be created.

Definition at line 78 of file xAODSpacePointMaker.h.

                                                                 {
      this, "PixelSpacePointContainerKey", "FPGAPixelSpacePoints",
      "Key for output pixel space point container"};

m_stripClusterKey

SG::ReadHandleKey<xAOD::StripClusterContainer> xAODSpacePointMaker::m_stripClusterKey

private

Initial value:

{
      this, "StripClusterContainerKey", "FPGAStripClusters",
      "Key for input strip cluster container"}

Key for the strip cluster container to read from.

Definition at line 73 of file xAODSpacePointMaker.h.

                                                              {
      this, "StripClusterContainerKey", "FPGAStripClusters",
      "Key for input strip cluster container"};

m_stripSpacePointsKey

SG::WriteHandleKey<xAOD::SpacePointContainer> xAODSpacePointMaker::m_stripSpacePointsKey

private

Initial value:

{
      this, "StripSpacePointContainerKey", "FPGAStripSpacePoints",
      "Key for output strip space point container"}

Key for the strip space points container to be created.

Definition at line 83 of file xAODSpacePointMaker.h.

                                                                 {
      this, "StripSpacePointContainerKey", "FPGAStripSpacePoints",
      "Key for output strip space point container"};

---

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

• xAODSpacePointMaker.h
• xAODSpacePointMaker.cxx