ActsTrk::StripClusteringTool Class Reference

#include <StripClusteringTool.h>

Inheritance diagram for ActsTrk::StripClusteringTool:

Collaboration diagram for ActsTrk::StripClusteringTool:

Public Types
using	StripRDORawData = SCT_RDORawData
using	StripID = SCT_ID

Public Member Functions
	StripClusteringTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual std::pair< unsigned int, unsigned int >	countCells (const RDOContainer &rdo_collection, const std::vector< IdentifierHash > &listOfIds, const InDetDD::SiDetectorElementCollection &detector_elements) const override
virtual StatusCode	clusterize (const EventContext &ctx, const RawDataCollection &RDOs, const InDet::SiDetectorElementStatus &stripDetElStatus, const InDetDD::SiDetectorElement &element, IStripClusteringTool::CellContainer &cellContainer) const override
virtual std::any	createEventDataCache (xAOD::StripClusterContainer &cont, std::size_t nClusterRDOs) const override
virtual StatusCode	makeClusters (const EventContext &ctx, const RDOContainer &rdo_container, const IStripClusteringTool::CellContainer &cellContainer, unsigned int module_i, const InDetDD::SiDetectorElement &element, unsigned int icluster, xAOD::StripClusterContainer &cont, std::any &vars) const override

Private Types
using	ClusterProxy = InPlaceClusterization::ClusterProxy<const IStripClusteringTool::CellContainer>
using	Cell = IStripClusteringTool::CellContainer::Cell

Private Member Functions
std::span< IStripClusteringTool::CellContainer::Cell >	unpackRDOs (const RawDataCollection &RDOs, const InDet::SiDetectorElementStatus &stripDetElStatus, const InDetDD::SiDetectorElement &element, IStripClusteringTool::CellContainer &cellContainer) const
bool	passTiming (const std::bitset< 3 > &timePattern) const
StatusCode	decodeTimeBins ()
StatusCode	makeCluster (size_t icluster, xAOD::StripCluster &cl, const ClusterProxy &cluster_proxy, const InDetDD::SiDetectorElement &element, const InDetDD::SiDetectorDesign &design, const double lorentzShift, Eigen::Matrix< float, 1, 1 > &localCov, StripAuxDataCache &auxDataCache) const

Static Private Member Functions
static bool	isBadStrip (const InDet::SiDetectorElementStatus *sctDetElStatus, IdentifierHash waferHash, std::int16_t strip)

Private Attributes
StringProperty	m_timeBinStr {this, "timeBins", ""}
ToolHandle< ISiLorentzAngleTool >	m_lorentzAngleTool
SG::ReadHandleKey< InDet::SiDetectorElementStatus >	m_stripDetElStatus
Gaudi::Property< bool >	m_checkBadModules
Gaudi::Property< unsigned int >	m_maxFiredStrips
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_stripDetEleCollKey
Gaudi::Property< bool >	m_isITk
Gaudi::Property< unsigned int >	m_errorStrategy {this, "errorStrategy", 0, "Use different error strategies for the strip clusters"}
int	m_timeBinBits [3] {-1, -1, -1}
const StripID *	m_stripID {nullptr}

Detailed Description

Definition at line 29 of file StripClusteringTool.h.

Member Typedef Documentation

Cell

using ActsTrk::StripClusteringTool::Cell = IStripClusteringTool::CellContainer::Cell

private

Definition at line 67 of file StripClusteringTool.h.

ClusterProxy

using ActsTrk::StripClusteringTool::ClusterProxy = InPlaceClusterization::ClusterProxy<const IStripClusteringTool::CellContainer>

private

Definition at line 66 of file StripClusteringTool.h.

StripID

using ActsTrk::StripClusteringTool::StripID = SCT_ID

Definition at line 32 of file StripClusteringTool.h.

StripRDORawData

using ActsTrk::StripClusteringTool::StripRDORawData = SCT_RDORawData

Definition at line 31 of file StripClusteringTool.h.

Constructor & Destructor Documentation

StripClusteringTool()

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

Definition at line 23 of file StripClusteringTool.cxx.

    : base_class(type,name,parent)
{
}

Member Function Documentation

clusterize()

StatusCode ActsTrk::StripClusteringTool::clusterize ( const EventContext & ctx, const RawDataCollection & RDOs, const InDet::SiDetectorElementStatus & stripDetElStatus, const InDetDD::SiDetectorElement & element, IStripClusteringTool::CellContainer & cellContainer ) const

overridevirtual

Definition at line 118 of file StripClusteringTool.cxx.

{
    IdentifierHash idHash = RDOs.identifyHash();
    IStripClusteringTool::CellContainer::ModuleRangeGuard rangeGuard(cellContainer.startNewModule(idHash));
 
    // At least an empty cluster collection needs to be always added because the
    // assumption is that there is one element per element RawDataCollection.
    bool goodModule = true;
    if (m_checkBadModules.value()) {
      goodModule = stripDetElStatus.isGood(idHash);
    }
 
    // If more than a certain number of RDOs set module to bad
    // in this case we skip clusterization
    if (!goodModule && m_maxFiredStrips != 0u) {
      unsigned int nFiredStrips = 0u;
      for (const SCT_RDORawData* rdo : RDOs) {
        nFiredStrips += rdo->getGroupSize();
      }
      goodModule |= (nFiredStrips <m_maxFiredStrips);
    }
 
    if (goodModule) {
       std::span<IStripClusteringTool::CellContainer::Cell>
          cellRange = unpackRDOs(RDOs, stripDetElStatus, element, cellContainer);
 
       static constexpr unsigned int SORT_BY_LOCAL_X=0u;
       namespace CL=Acts::InPlaceClusterization;
       CL::clusterize<SORT_BY_LOCAL_X, std::uint16_t>(cellRange,
                                                      CL::defaultConnectionHelper<CL::EConnectionType::CommonEdgeOrCorner>(cellRange));
 
       // set the cell range per cluster
       Acts::InPlaceClusterization::for_each_cluster(cellRange,
                                                     [&cellContainer](std::span<IStripClusteringTool::CellContainer::Cell> &,
                                                                      unsigned int idx_begin,
                                                                      unsigned int idx_end) {
          cellContainer.registerNewCluster(idx_begin,idx_end);
       });
    }
    // must add a range for every call otherwise the cell container and
    // the list of processed modules get out of sync.
    cellContainer.registerClustersForNewModule(rangeGuard.range());
    return StatusCode::SUCCESS;
}

countCells()

std::pair< unsigned int, unsigned int > ActsTrk::StripClusteringTool::countCells ( const RDOContainer & rdo_collection, const std::vector< IdentifierHash > & listOfIds, const InDetDD::SiDetectorElementCollection & detector_elements ) const

overridevirtual

Definition at line 52 of file StripClusteringTool.cxx.

                                                                                                   {
   auto getNHits =[](const InDetRawDataCollection<SCT_RDORawData> &RDOs,
                     [[maybe_unused]] const InDetDD::SiDetectorElementCollection &elements )
      -> unsigned int
   {
      unsigned int n_hits = 0u;
      for (const SCT_RDORawData* rdo : RDOs) {
        n_hits += rdo->getGroupSize();
      }
      return n_hits;
   };
   unsigned int n_hits=0;
   if (listOfIds.empty()) {
      for (const InDetRawDataCollection<SCT_RDORawData> *RDOs : rdoContainer) {
         assert( RDOs);
         n_hits += getNHits(*RDOs, detector_elements);
      }
   }
   else {
      for (const IdentifierHash& id : listOfIds) {
         if (not id.is_valid()) continue;
         const InDetRawDataCollection<SCT_RDORawData> *RDOs = rdoContainer.indexFindPtr(id);
         if (RDOs) { // necessary ?
            n_hits += getNHits(*RDOs, detector_elements);
         }
      }
   }
   return {n_hits,n_hits};
}

createEventDataCache()

std::any ActsTrk::StripClusteringTool::createEventDataCache ( xAOD::StripClusterContainer & cont, std::size_t nClusterRDOs ) const

overridevirtual

Definition at line 92 of file StripClusteringTool.cxx.

{
   return std::any (StripAuxDataCache (cont, nClusterRDOs));
}

decodeTimeBins()

StatusCode ActsTrk::StripClusteringTool::decodeTimeBins ( )

private

Definition at line 98 of file StripClusteringTool.cxx.

{
    for (size_t i = 0; i < m_timeBinStr.size(); i++) {
    if (i >= 3) {
        ATH_MSG_WARNING("Time bin string has excess characters");
        break;
    }
    switch (std::toupper(m_timeBinStr[i])) {
    case 'X': m_timeBinBits[i] = -1; break;
    case '0': m_timeBinBits[i] =  0; break;
    case '1': m_timeBinBits[i] =  1; break;
    default:
        ATH_MSG_FATAL("Invalid time bin string: " << m_timeBinStr);
        return StatusCode::FAILURE;
    }
    }
    return StatusCode::SUCCESS;
}

initialize()

StatusCode ActsTrk::StripClusteringTool::initialize ( )

overridevirtual

Definition at line 29 of file StripClusteringTool.cxx.

{
    ATH_MSG_DEBUG("Initializing " << name() << "...");
 
    ATH_MSG_DEBUG(m_stripDetElStatus);
    ATH_MSG_DEBUG(m_checkBadModules);
    ATH_MSG_DEBUG(m_maxFiredStrips);
    ATH_MSG_DEBUG(m_stripDetEleCollKey);
    ATH_MSG_DEBUG(m_isITk);
    ATH_MSG_DEBUG(m_errorStrategy);
 
    ATH_CHECK(m_lorentzAngleTool.retrieve());
    ATH_CHECK(decodeTimeBins());    
 
    ATH_CHECK(m_stripDetElStatus.initialize(not m_stripDetElStatus.empty()));
    ATH_CHECK(m_stripDetEleCollKey.initialize());
 
    ATH_CHECK( detStore()->retrieve(m_stripID, "SCT_ID") );
    
    return StatusCode::SUCCESS;
}

isBadStrip()

bool ActsTrk::StripClusteringTool::isBadStrip ( const InDet::SiDetectorElementStatus * sctDetElStatus, IdentifierHash waferHash, std::int16_t strip )

staticprivate

Definition at line 381 of file StripClusteringTool.cxx.

{
    if (stripDetElStatus) {
    return not stripDetElStatus->isCellGood(waferHash.value(), strip) ;
    }
    return false;
}

makeCluster()

StatusCode ActsTrk::StripClusteringTool::makeCluster ( size_t icluster, xAOD::StripCluster & cl, const ClusterProxy & cluster_proxy, const InDetDD::SiDetectorElement & element, const InDetDD::SiDetectorDesign & design, const double lorentzShift, Eigen::Matrix< float, 1, 1 > & localCov, StripAuxDataCache & auxDataCache ) const

private

Definition at line 307 of file StripClusteringTool.cxx.

{
    auto [localPos, globalPos]
      = computePosition(clusterProxy, element, design, lorentzShift, m_isITk);
 
    // For Strip Clusters the identifier is taken from the front rod list object
    // This is the same strategy used in Athena:
    // Since clusterId is arbitary (it only needs to be unique) just use ID of first strip
    // For strip Cluster it has been found that "identifierOfPosition" does not produces unique values
 
 
    // If requiring broad errors, use the cluster size as error -
    // TODO use SiWidth to get the right cluster size as I'm assuming equal strip pitch
    std::size_t size = clusterProxy.size();
    if (m_errorStrategy == 1)   {// use width
      
      localCov *= size*size;
      
    } else if (m_errorStrategy == 2) { //use tuned error as function of size
      
      if (size == 1)
        localCov *= oneStripSF;
      else if (size == 2)
        localCov *= twoStripSF*size*size;
      else
        localCov *= size*size;
      
    }
 
    if (not m_isITk) {
      localCov(0,0) = computeRotatedLocalCov(clusterProxy, localPos(0,0), localCov(0,0), element, design);
    }
 
    cl.setMeasurement<1>(element.identifyHash(), localPos, localCov);
    Identifier frontRDOId = m_stripID->strip_id(element.identify(), clusterProxy.front().coordinates()[0]);
    cl.setIdentifier( frontRDOId.get_compact() );
 
    // Do I really need the global position in fast tracking?
    cl.globalPosition() = globalPos;     
    
    cl.setChannelsInPhi(size);
 
    unsigned int n_rdos = auxDataCache.rdoList.getBeginIndex(icluster);
    Identifier waferId=element.identify();
    using CellProxy = InPlaceClusterization::CellProxy<const StripClusteringTool::CellContainer>;
    for (CellProxy cellProxy : clusterProxy) {
       Identifier rdoId = m_stripID->strip_id(waferId, cellProxy.coordinates()[0]);
       auxDataCache.rdoList.setValue(n_rdos,rdoId.get_compact());
       ++n_rdos;
    }
    auxDataCache.rdoList.updateEndIndex(icluster,n_rdos);
    
    return StatusCode::SUCCESS;
}

makeClusters()

StatusCode ActsTrk::StripClusteringTool::makeClusters ( const EventContext & ctx, const RDOContainer & rdo_container, const IStripClusteringTool::CellContainer & cellContainer, unsigned int module_i, const InDetDD::SiDetectorElement & element, unsigned int icluster, xAOD::StripClusterContainer & cont, std::any & vars ) const

overridevirtual

Definition at line 169 of file StripClusteringTool.cxx.

{
    const IdentifierHash idHash = element.identifyHash();
    double lorentzShift = m_lorentzAngleTool->getLorentzShift(idHash, ctx);
 
    const InDetDD::SiDetectorDesign& design = element.design();
    // get the pitch, this will be the local covariance for the cluster
 
    assert((not m_isITk) || element.isBarrel() ||  dynamic_cast<const InDetDD::StripStereoAnnulusDesign*>(&element.design()) !=nullptr);
    float pitch = (element.isBarrel() or (not m_isITk))
      ? design.phiPitch()
      : static_cast<const InDetDD::StripStereoAnnulusDesign&>(element.design()).phiPitchPhi();
    Eigen::Matrix<float,1,1> localCov(pitch * pitch * ONE_TWELFTH);
 
    StripAuxDataCache* auxDataCache = std::any_cast<StripAuxDataCache> (&cache);
    if (!auxDataCache) throw std::bad_any_cast();
 
    using CellContainerProxy = InPlaceClusterization::CellContainerProxy<const IStripClusteringTool::CellContainer>;
    using ModuleProxy = InPlaceClusterization::ModuleProxy<const IStripClusteringTool::CellContainer>;
    using ClusterProxy = InPlaceClusterization::ClusterProxy<const IStripClusteringTool::CellContainer>;
    CellContainerProxy cellContainerProxy(&cellContainer);
    ModuleProxy moduleProxy(cellContainerProxy[imodule]);
 
    for (ClusterProxy clusterProxy: moduleProxy) {
       assert( icluster< cont.size() && cont[icluster]);
       xAOD::StripCluster &stripCluster= *cont[icluster];
       ATH_CHECK(makeCluster(icluster++,
                             stripCluster,
                             clusterProxy,
                             element,
                             design,
                             lorentzShift,
                             localCov,
                             *auxDataCache));
    }
    return StatusCode::SUCCESS;
}

passTiming()

bool ActsTrk::StripClusteringTool::passTiming ( const std::bitset< 3 > & timePattern ) const

private

Definition at line 370 of file StripClusteringTool.cxx.

                                                                          {
    // Convert the given timebin to a bit set and test each bit
    // if bit is -1 (i.e. X) it always passes, other wise require exact match of 0/1
    // N.B bitset has opposite order to the bit pattern we define
    if (m_timeBinBits[0] != -1 and timePattern.test(2) != static_cast<bool>(m_timeBinBits[0])) return false;
    if (m_timeBinBits[1] != -1 and timePattern.test(1) != static_cast<bool>(m_timeBinBits[1])) return false;
    if (m_timeBinBits[2] != -1 and timePattern.test(0) != static_cast<bool>(m_timeBinBits[2])) return false;
    return true;
}

unpackRDOs()

std::span< IStripClusteringTool::CellContainer::Cell > ActsTrk::StripClusteringTool::unpackRDOs ( const RawDataCollection & RDOs, const InDet::SiDetectorElementStatus & stripDetElStatus, const InDetDD::SiDetectorElement & element, IStripClusteringTool::CellContainer & cellContainer ) const

private

Definition at line 393 of file StripClusteringTool.cxx.

{
    const InDetDD::SiDetectorDesign& design = element.design();
 
    //Check type in debug build otherwise assume it is correct
    assert(dynamic_cast<const InDetDD::SCT_ModuleSideDesign*>(&design)!=nullptr);
    std::size_t ncells = static_cast<size_t>(static_cast<const InDetDD::SCT_ModuleSideDesign&>(design).cells());
     
    IStripClusteringTool::CellContainer::ModuleRangeGuard rangeGuard(cellContainer, RDOs.identifyHash() );
    // Simple single-entry cache
    IdentifierHash waferHash=RDOs.identifyHash();
 
    for (unsigned int rdo_i=0; rdo_i<RDOs.size(); ++rdo_i) {
        const StripRDORawData *raw=RDOs[rdo_i];
 
        //Check type in debug build otherwise assume it is correct
        assert(dynamic_cast<const SCT3_RawData*>(raw)!=nullptr);
    const SCT3_RawData* raw3 = static_cast<const SCT3_RawData*>(raw);
 
    std::bitset<3> timePattern(raw3->getTimeBin());
    if (!passTiming(timePattern)) {
        ATH_MSG_DEBUG("Strip failed timing check");
        continue;
    }
 
    Identifier firstStripId = raw->identify();
    Identifier waferId = m_stripID->wafer_id(firstStripId);
    
        assert( waferHash == m_stripID->wafer_hash(waferId) );
 
        std::int16_t iFirstStrip = static_cast<std::int16_t>(m_stripID->strip(firstStripId));
        assert(m_stripID->strip(firstStripId)==iFirstStrip);
 
        assert( ncells == static_cast<std::uint16_t>(ncells) );
    std::int16_t iMaxStrip = std::min(
            static_cast<std::int16_t>(iFirstStrip + raw->getGroupSize()),
            static_cast<std::int16_t>(ncells));
    
    for (std::int16_t strip_i = iFirstStrip; strip_i < iMaxStrip; strip_i++) {
        if (isBadStrip(&stripDetElStatus, waferHash, strip_i)) {
        // Bad strip, throw it out to minimize useless work.
               ATH_MSG_DEBUG("Bad strip encountered on module " << waferHash << " : "
                              << m_stripID->strip_id(waferId, strip_i)
                  << ", wafer is: " << waferId << " strip is "<< strip_i
                              << " hash " << m_stripID->wafer_hash(waferId));
        } else {
        // Good strip!
 
               std::array<std::int16_t,1> coordinates{strip_i};
               cellContainer.emplace_back_cell(coordinates, rdo_i);
        }
    }
    }
 
    return rangeGuard.moduleCellSpan();
}

Member Data Documentation

m_checkBadModules

Gaudi::Property<bool> ActsTrk::StripClusteringTool::m_checkBadModules

private

Initial value:

{this, "checkBadModules", true,
      "Check bad modules using the conditions summary tool"}

Definition at line 102 of file StripClusteringTool.h.

                                          {this, "checkBadModules", true,
      "Check bad modules using the conditions summary tool"};

m_errorStrategy

Gaudi::Property<unsigned int> ActsTrk::StripClusteringTool::m_errorStrategy {this, "errorStrategy", 0, "Use different error strategies for the strip clusters"}

private

Definition at line 114 of file StripClusteringTool.h.

{this, "errorStrategy", 0, "Use different error strategies for the strip clusters"};

m_isITk

Gaudi::Property<bool> ActsTrk::StripClusteringTool::m_isITk

private

Initial value:

{this, "isITk", true,
      "True if running in ITk"}

Definition at line 111 of file StripClusteringTool.h.

                                {this, "isITk", true,
      "True if running in ITk"};

m_lorentzAngleTool

ToolHandle<ISiLorentzAngleTool> ActsTrk::StripClusteringTool::m_lorentzAngleTool

private

Initial value:

{this, "LorentzAngleTool", "",
      "Tool to retreive Lorentz angle of Si detector module"
    }

Definition at line 94 of file StripClusteringTool.h.

                                                       {this, "LorentzAngleTool", "",
      "Tool to retreive Lorentz angle of Si detector module"
    };

m_maxFiredStrips

Gaudi::Property<unsigned int> ActsTrk::StripClusteringTool::m_maxFiredStrips

private

Initial value:

{this, "maxFiredStrips", 384u,
      "Threshold of number of fired strips per wafer. 0 disables the per-wafer cut."}

Definition at line 105 of file StripClusteringTool.h.

                                                 {this, "maxFiredStrips", 384u,
      "Threshold of number of fired strips per wafer. 0 disables the per-wafer cut."};

m_stripDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> ActsTrk::StripClusteringTool::m_stripDetEleCollKey

private

Initial value:

{this, "StripDetEleCollKey", "ITkStripDetectorElementCollection",
      "SiDetectorElementCollection key for strip"}

Definition at line 108 of file StripClusteringTool.h.

                                                                                 {this, "StripDetEleCollKey", "ITkStripDetectorElementCollection",
      "SiDetectorElementCollection key for strip"};

m_stripDetElStatus

SG::ReadHandleKey<InDet::SiDetectorElementStatus> ActsTrk::StripClusteringTool::m_stripDetElStatus

private

Initial value:

{this, "StripDetElStatus", "",
      "SiDetectorElementStatus for strip"}

Definition at line 99 of file StripClusteringTool.h.

                                                                     {this, "StripDetElStatus", "",
      "SiDetectorElementStatus for strip"};

m_stripID

const StripID* ActsTrk::StripClusteringTool::m_stripID {nullptr}

private

Definition at line 119 of file StripClusteringTool.h.

{nullptr};

m_timeBinBits

int ActsTrk::StripClusteringTool::m_timeBinBits[3] {-1, -1, -1}

private

Definition at line 116 of file StripClusteringTool.h.

{-1, -1, -1};

m_timeBinStr

StringProperty ActsTrk::StripClusteringTool::m_timeBinStr {this, "timeBins", ""}

private

Definition at line 92 of file StripClusteringTool.h.

{this, "timeBins", ""};

---

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

• StripClusteringTool.h
• StripClusteringTool.cxx