ActsTrk::StripClusteringTool Class Reference

#include <StripClusteringTool.h>

Inheritance diagram for ActsTrk::StripClusteringTool:

Collaboration diagram for ActsTrk::StripClusteringTool:

Classes
struct	Cell
struct	Cluster

Public Types
using	StripRDORawData = SCT_RDORawData
using	StripID = SCT_ID
using	CellCollection = std::vector< Cell >
using	ClusterCollection = std::vector< Cluster >

Public Member Functions
	StripClusteringTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	clusterize (const InDetRawDataCollection< StripRDORawData > &RDOs, const StripID &stripID, const EventContext &ctx, xAOD::StripClusterContainer &container) const override

Private Member Functions
bool	passTiming (const std::bitset< 3 > &timePattern) const
StatusCode	decodeTimeBins ()
std::optional< std::pair< std::vector< Cell >, bool > >	unpackRDOs (const InDetRawDataCollection< StripRDORawData > &RDOs, const StripID &idHelper, const InDet::SiDetectorElementStatus *sctDetElStatus) const
bool	isBadStrip (const InDet::SiDetectorElementStatus *sctDetElStatus, const StripID &idHelper, IdentifierHash waferHash, Identifier stripId) const
StatusCode	makeCluster (const StripClusteringTool::Cluster &cluster, double LorentzShift, const StripID &stripID, const InDetDD::SiDetectorElement *element, xAOD::StripCluster &container) const

Private Attributes
StringProperty	m_timeBinStr {this, "timeBins", ""}
ToolHandle< ISiLorentzAngleTool >	m_lorentzAngleTool
SG::ReadHandleKey< InDet::SiDetectorElementStatus >	m_stripDetElStatus
ToolHandle< IInDetConditionsTool >	m_conditionsTool
Gaudi::Property< bool >	m_checkBadModules
Gaudi::Property< unsigned int >	m_maxFiredStrips
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_stripDetEleCollKey
int	m_timeBinBits [3] {-1, -1, -1}

Detailed Description

Definition at line 26 of file StripClusteringTool.h.

Member Typedef Documentation

CellCollection

using ActsTrk::StripClusteringTool::CellCollection = std::vector<Cell>

Definition at line 47 of file StripClusteringTool.h.

ClusterCollection

using ActsTrk::StripClusteringTool::ClusterCollection = std::vector<Cluster>

Definition at line 48 of file StripClusteringTool.h.

StripID

using ActsTrk::StripClusteringTool::StripID = SCT_ID

Definition at line 30 of file StripClusteringTool.h.

StripRDORawData

using ActsTrk::StripClusteringTool::StripRDORawData = SCT_RDORawData

Definition at line 29 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 43 of file StripClusteringTool.cxx.

    : base_class(type,name,parent)
{
}

Member Function Documentation

clusterize()

StatusCode ActsTrk::StripClusteringTool::clusterize ( const InDetRawDataCollection< StripRDORawData > &  RDOs, const StripID &  stripID, const EventContext &  ctx, xAOD::StripClusterContainer &  container  ) const

overridevirtual

Definition at line 83 of file StripClusteringTool.cxx.

{
    IdentifierHash idHash = RDOs.identifyHash();
 
    SG::ReadHandle<InDet::SiDetectorElementStatus> status;
    if (!m_stripDetElStatus.empty()) {
    status = SG::makeHandle(m_stripDetElStatus, ctx);
    if (!status.isValid()) {
        ATH_MSG_FATAL("Invalid SiDetectorelementStatus");
        return StatusCode::FAILURE;
    }
    }
 
    bool goodModule = true;
    if (m_checkBadModules.value()) {
    if (!m_stripDetElStatus.empty()) {
        goodModule = status->isGood(idHash);
    } else {
        goodModule = m_conditionsTool->isGood(idHash, ctx);
    }
    }
    VALIDATE_STATUS_ARRAY(
    m_checkBadModules.value() && !m_stripDetElStatus.empty(),
    status->isGood(idHash), m_conditionsTool->isGood(idHash));
      
    if (!goodModule) {
    ATH_MSG_DEBUG("Strip module failed status check");
    return StatusCode::SUCCESS;
    }
      
    // If more than a certain number of RDOs set module to bad
    // in this case we skip clusterization
    if (m_maxFiredStrips != 0u) {
    unsigned int nFiredStrips = 0u;
    for (const SCT_RDORawData* rdo : RDOs) {
        nFiredStrips += rdo->getGroupSize();
    }
    if (nFiredStrips > m_maxFiredStrips)
        return StatusCode::SUCCESS;
    }
 
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> stripDetEleHandle(
    m_stripDetEleCollKey, ctx);
    ATH_CHECK( stripDetEleHandle.isValid() );
    const InDetDD::SiDetectorElementCollection* stripDetEle(*stripDetEleHandle);
    if (stripDetEle == nullptr) {
    ATH_MSG_FATAL("Invalid SiDetectorElementCollection");
    return StatusCode::FAILURE;
    }
 
    const InDetDD::SiDetectorElement* element =
    stripDetEle->getDetectorElement(idHash);
 
    const InDet::SiDetectorElementStatus *stripDetElStatus =
    m_stripDetElStatus.empty() ? nullptr : status.cptr();
 
    std::optional<std::pair<CellCollection,bool>> unpckd
    = unpackRDOs(RDOs, stripID, stripDetElStatus);
    if (not unpckd.has_value()) {
    ATH_MSG_FATAL("Error encountered while unpacking strip RDOs!");
    return StatusCode::FAILURE;
    }
 
    auto& [cells, badStripOnModule] = *unpckd;
 
    ClusterCollection clusters =
    Acts::Ccl::createClusters<CellCollection, ClusterCollection, 1>(cells);
 
    std::size_t previousSizeContainer = container.size();
    // Fast insertion trick
    std::vector<xAOD::StripCluster*> toAddCollection;
    toAddCollection.reserve(clusters.size());
    for (std::size_t i(0); i<clusters.size(); ++i)
      toAddCollection.push_back(new xAOD::StripCluster());
    container.insert(container.end(), toAddCollection.begin(), toAddCollection.end());
 
    double lorentzShift
    = m_lorentzAngleTool->getLorentzShift(element->identifyHash());
 
    for (std::size_t i(0); i<clusters.size(); ++i) {
      Cluster& cl = clusters[i];
    // Bad strips on a module invalidates the hitsInThirdTimeBin word.
    // Therefore set it to 0 if that's the case.
    if (badStripOnModule) {
        cl.hitsInThirdTimeBin = 0;
    }
    try {
        ATH_CHECK(makeCluster(cl, lorentzShift, stripID, element, *container[previousSizeContainer+i]));
    } catch (const std::exception& e) {
        ATH_MSG_FATAL("Exception thrown while creating xAOD::StripCluster:"
              << e.what());
        ATH_MSG_FATAL("Detector Element identifier: " << element->identify());
        ATH_MSG_FATAL("Strip Identifiers in cluster:");
        for (const Identifier& id : cl.ids)
        ATH_MSG_FATAL("  " << id);
        return StatusCode::FAILURE;
    }
    }
 
    return StatusCode::SUCCESS;
}

decodeTimeBins()

StatusCode ActsTrk::StripClusteringTool::decodeTimeBins ( )

private

Definition at line 63 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 49 of file StripClusteringTool.cxx.

{
    ATH_MSG_DEBUG("Initializing " << name() << "...");
 
    ATH_CHECK(m_conditionsTool.retrieve());
    ATH_CHECK(m_lorentzAngleTool.retrieve());
    ATH_CHECK(decodeTimeBins());    
 
    ATH_CHECK(m_stripDetElStatus.initialize(not m_stripDetElStatus.empty()));
    ATH_CHECK(m_stripDetEleCollKey.initialize());
 
    return StatusCode::SUCCESS;
}

isBadStrip()

bool ActsTrk::StripClusteringTool::isBadStrip ( const InDet::SiDetectorElementStatus *  sctDetElStatus, const StripID &  idHelper, IdentifierHash  waferHash, Identifier  stripId  ) const

private

Definition at line 268 of file StripClusteringTool.cxx.

{
    if (stripDetElStatus) {
        const int strip_i{stripID.strip(stripId)};
    VALIDATE_STATUS_ARRAY(
        stripDetElStatus,
        stripDetElStatus->isCellGood(waferHash.value(), strip_i),
        m_conditionsTool->isGood(stripId, InDetConditions::SCT_STRIP));
    return not stripDetElStatus->isCellGood(waferHash.value(), strip_i) ;
    }
    const EventContext& ctx{Gaudi::Hive::currentContext()};
    return not m_conditionsTool->isGood(stripId, InDetConditions::SCT_STRIP, ctx);
}

makeCluster()

StatusCode ActsTrk::StripClusteringTool::makeCluster ( const StripClusteringTool::Cluster &  cluster, double  LorentzShift, const StripID &  stripID, const InDetDD::SiDetectorElement *  element, xAOD::StripCluster &  container  ) const

private

Definition at line 232 of file StripClusteringTool.cxx.

{
 
    IdentifierHash idHash = element->identifyHash();
    auto [pos, localPos, localCov, globalPos]
    = computePosition(cluster, lorentzShift, stripID, element);
 
    // 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
    cl.setMeasurement<1>(idHash, localPos, localCov);
    cl.setIdentifier( cluster.ids.front().get_compact() );
    cl.globalPosition() = globalPos;
    cl.setRDOlist(cluster.ids);
    cl.setChannelsInPhi(cluster.ids.size());
 
    return StatusCode::SUCCESS;
}

passTiming()

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

private

Definition at line 257 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::optional< std::pair< StripClusteringTool::CellCollection, bool > > ActsTrk::StripClusteringTool::unpackRDOs ( const InDetRawDataCollection< StripRDORawData > &  RDOs, const StripID &  idHelper, const InDet::SiDetectorElementStatus *  sctDetElStatus  ) const

private

Definition at line 287 of file StripClusteringTool.cxx.

{
    CellCollection cells;
    bool badStripOnModule{false};
 
    for (const StripRDORawData * raw : RDOs) {
    const SCT3_RawData* raw3 = dynamic_cast<const SCT3_RawData*>(raw);
    if (!raw3) {
        ATH_MSG_ERROR("Casting into SCT3_RawData failed");
        return {};
    }
 
    std::bitset<3> timePattern(raw3->getTimeBin());
    if (!passTiming(timePattern)) {
        ATH_MSG_DEBUG("Strip failed timing check");
        continue;
    }
 
    Identifier firstStripId = raw->identify();
    Identifier waferId = stripID.wafer_id(firstStripId);
    IdentifierHash waferHash = stripID.wafer_hash(waferId);
    size_t iFirstStrip = static_cast<size_t>(stripID.strip(firstStripId));
    size_t iMaxStrip = std::min(
        iFirstStrip + raw->getGroupSize(),
        static_cast<size_t>(stripID.strip_max(waferId)) + 1
        );
 
    for (size_t i = iFirstStrip; i < iMaxStrip; i++) {
        Identifier stripIdent = stripID.strip_id(waferId, i);
        if (isBadStrip(stripDetElStatus, stripID, waferHash, stripIdent)) {
        // Bad strip, throw it out to minimize useless work.
        ATH_MSG_DEBUG("Bad strip encountered:" << stripIdent
                  << ", wafer is: " << waferId);
        badStripOnModule = true;
        } else {
        // Good strip!
        cells.emplace_back(i, stripIdent, std::move(timePattern));
        }
    }
    }
    return std::make_pair(cells, badStripOnModule);
}

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 98 of file StripClusteringTool.h.

m_conditionsTool

ToolHandle<IInDetConditionsTool> ActsTrk::StripClusteringTool::m_conditionsTool

private

Initial value:

{this, "conditionsTool", "",
      "Conditions summary tool"}

Definition at line 95 of file StripClusteringTool.h.

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 87 of file StripClusteringTool.h.

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 101 of file StripClusteringTool.h.

m_stripDetEleCollKey

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

private

Initial value:

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

Definition at line 104 of file StripClusteringTool.h.

m_stripDetElStatus

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

private

Initial value:

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

Definition at line 92 of file StripClusteringTool.h.

m_timeBinBits

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

private

Definition at line 107 of file StripClusteringTool.h.

m_timeBinStr

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

private

Definition at line 85 of file StripClusteringTool.h.

---

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

• StripClusteringTool.h
• StripClusteringTool.cxx