InDet::SCT_ClusteringTool Class Reference

AlgTool for SCT_Clusterization. More...

#include <SCT_ClusteringTool.h>

Inheritance diagram for InDet::SCT_ClusteringTool:

Collaboration diagram for InDet::SCT_ClusteringTool:

Classes
struct	DimensionAndPosition
	In-class struct to store the centre and width of a cluster. More...

Public Member Functions
	SCT_ClusteringTool (const std::string &type, const std::string &name, const IInterface *parent)
	Normal constructor for an AlgTool; 'properties' are also declared here.
virtual StatusCode	initialize () override
	Retrieve the necessary services in initialize.
virtual	~SCT_ClusteringTool ()=default
	Defaul destructor.
SCT_ClusterCollection *	clusterize (const InDetRawDataCollection< SCT_RDORawData > &RDOs, const SCT_ID &idHelper, const InDet::SiDetectorElementStatus *sctDetElementStatus, SCTClusteringCache &cache, DataPool< SCT_Cluster > *dataItemsPool, const EventContext &ctx) const override
	Clusterize method the SCT RDOs. This method is the main one of this class.
SCT_ClusterCollection *	fastClusterize (const InDetRawDataCollection< SCT_RDORawData > &RDOs, const SCT_ID &idHelper, const InDet::SiDetectorElementStatus *sctDetElementStatus, SCTClusteringCache &cache, DataPool< SCT_Cluster > *dataItemsPool, const EventContext &ctx) const
	A new fast method originally implemented for ITk.

Private Types
using	IdVec_t = std::vector<Identifier>

Private Attributes
Tool Handles
ToolHandle< IInDetConditionsTool >	m_conditionsTool
ToolHandle< ClusterMakerTool >	m_clusterMaker
ToolHandle< ISiLorentzAngleTool >	m_lorentzAngleTool
Flags to configure SCT_ClusteringTool
IntegerProperty	m_errorStrategy {this, "errorStrategy", 1}
BooleanProperty	m_checkBadChannels {this, "checkBadChannels", true}
StringProperty	m_timeBinStr {this, "timeBins", ""}
BooleanProperty	m_innermostBarrelX1X {this, "innermostBarrelX1X", false}
BooleanProperty	m_innertwoBarrelX1X {this, "innertwoBarrelX1X", false}
BooleanProperty	m_majority01X {this, "majority01X", false}
BooleanProperty	m_useRowInformation {this, "useRowInformation", false}
BooleanProperty	m_doFastClustering {this, "doFastClustering", true}
BooleanProperty	m_doSimplePosWidth {this, "doSimplePositionWidthCalculation", false, "Always use the simpler position and width calculation in fast clustering"}

ReadCondHandleKeys
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey
SG::ReadHandleKey< InDet::SiDetectorElementStatus >	m_sctDetElStatus
	Optional read handle to get status data to test whether a SCT detector element is good.
int	m_timeBinBits [3] {-1, -1, -1}
	Time bin bits for timing requirement.
static void	addStripsToCluster (const Identifier &firstStripId, unsigned int nStrips, IdVec_t &clusterVector, const SCT_ID &idHelper)
	Add strips to a cluster vector without checking for bad strips.
static DimensionAndPosition	clusterDimensions (int firstStrip, int lastStrip, const InDetDD::SiDetectorElement *element, const SCT_ID &idHelper)
	Calculate the cluster position and width given the first and last strip numbers for this element.
static DimensionAndPosition	clusterDimensionsInclRow (int firstStrip, int lastStrip, int row, const InDetDD::SiDetectorElement *element, const InDetDD::SCT_ModuleSideDesign *design)
	Calculate the cluster position and width given the first,last strip, and row numbers for this element for ITk.
void	addStripsToClusterWithChecks (const Identifier &firstStripId, unsigned int nStrips, IdVec_t &clusterVector, std::vector< IdVec_t > &idGroups, const SCT_ID &idHelper, const InDet::SiDetectorElementStatus *det_el_status, const EventContext &ctx) const
	Add strips to a cluster vector checking for bad strips.
void	addStripsToClusterInclRows (const Identifier &firstStripId, unsigned int nStrips, IdVec_t &clusterVector, std::vector< IdVec_t > &idGroups, const SCT_ID &idHelper, const InDet::SiDetectorElementStatus *det_el_status, const EventContext &ctx) const
	Add strips to a cluster vector including row variable for ITk.
IdVec_t	recluster (IdVec_t &clusterVector, std::vector< IdVec_t > &idGroups) const
	Recluster the current vector, splitting on bad strips, and insert those new groups to the idGroups vector.
bool	isBad (const InDet::SiDetectorElementStatus *sctDetElStatus, const SCT_ID &sctID, const IdentifierHash &waferHash, const Identifier &stripId, const EventContext &ctx) const
	In-class facade on the 'isGood' method for a strip identifier.
StatusCode	decodeTimeBins ()
	Convert time bin string to array of 3 bits.
StatusCode	decodeTimeBin (char timeBin, int &bit) const
	Convert a single time bin char to an int, bit is modified.

Test the clusters time bin to see if matches pattern
static bool	testTimeBins01X (int timeBin)
static bool	testTimeBinsX1X (int timeBin)
bool	testTimeBins (int timeBin) const
bool	testTimeBinsN (const std::bitset< 3 > &timePattern) const

Detailed Description

AlgTool for SCT_Clusterization.

Input is from RDOs, assumed to be sorted. They are then scanned in order and neighbouring RDOs are grouped together.

Definition at line 47 of file SCT_ClusteringTool.h.

Member Typedef Documentation

IdVec_t

using InDet::SCT_ClusteringTool::IdVec_t = std::vector<Identifier>

private

Definition at line 50 of file SCT_ClusteringTool.h.

Constructor & Destructor Documentation

SCT_ClusteringTool()

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

Normal constructor for an AlgTool; 'properties' are also declared here.

Definition at line 55 of file SCT_ClusteringTool.cxx.

                                                                                                               :
    base_class(type, name, parent)
  {
  }

~SCT_ClusteringTool()

virtual InDet::SCT_ClusteringTool::~SCT_ClusteringTool ( )

virtualdefault

Defaul destructor.

Member Function Documentation

addStripsToCluster()

void InDet::SCT_ClusteringTool::addStripsToCluster ( const Identifier & firstStripId, unsigned int nStrips, IdVec_t & clusterVector, const SCT_ID & idHelper )

staticprivate

Add strips to a cluster vector without checking for bad strips.

Definition at line 174 of file SCT_ClusteringTool.cxx.

                                                                                                            {
    const unsigned int firstStripNumber(idHelper.strip(firstStripId));
    const unsigned int endStripNumber(firstStripNumber + nStrips); // one-past-the-end
    const Identifier   waferId(idHelper.wafer_id(firstStripId));
    clusterVector.reserve(clusterVector.size() + nStrips);
 
    for (unsigned int stripNumber(firstStripNumber); stripNumber not_eq endStripNumber; ++stripNumber) {
      const Identifier stripId(idHelper.strip_id(waferId, stripNumber));
      clusterVector.push_back(stripId);
    }
  }

addStripsToClusterInclRows()

void InDet::SCT_ClusteringTool::addStripsToClusterInclRows ( const Identifier & firstStripId, unsigned int nStrips, IdVec_t & clusterVector, std::vector< IdVec_t > & idGroups, const SCT_ID & idHelper, const InDet::SiDetectorElementStatus * det_el_status, const EventContext & ctx ) const

private

Add strips to a cluster vector including row variable for ITk.

Definition at line 233 of file SCT_ClusteringTool.cxx.

                                                                                    {
 
    const unsigned int firstStripNumber(idHelper.strip(firstStripId));
    const unsigned int firstRowNumber(idHelper.row(firstStripId));
    const unsigned int endStripNumber(firstStripNumber + nStrips); // one-past-the-end
    const Identifier   waferId(idHelper.wafer_id(firstStripId));
    IdentifierHash     waferHash( idHelper.wafer_hash(waferId) );
 
    clusterVector.reserve(clusterVector.size() + nStrips);
    static const Identifier badId;
    unsigned int nBadStrips(0);
    for (unsigned int stripNumber(firstStripNumber); stripNumber not_eq endStripNumber; ++stripNumber) {
      Identifier stripId(idHelper.strip_id(waferId, firstRowNumber, stripNumber));
      if (isBad(det_el_status, idHelper, waferHash, stripId, ctx)) {
        ++nBadStrips;
        stripId = badId;
      }
      clusterVector.push_back(stripId);
    }
 
    // Maybe all the strips are bad, clear the cluster vector
    if (clusterVector.size() == nBadStrips) {
      clusterVector.clear();
      // No need to recluster if vector is empty (same true if empty for other reasons)
      return;
    }
 
    // Now we have one vector of stripIds, some of which may be 'bad'
    if (nBadStrips != 0) {
      clusterVector=recluster(clusterVector, idGroups);
      // After this, the cluster vector is either empty or has the last good cluster
    }
  }

addStripsToClusterWithChecks()

void InDet::SCT_ClusteringTool::addStripsToClusterWithChecks ( const Identifier & firstStripId, unsigned int nStrips, IdVec_t & clusterVector, std::vector< IdVec_t > & idGroups, const SCT_ID & idHelper, const InDet::SiDetectorElementStatus * det_el_status, const EventContext & ctx ) const

private

Add strips to a cluster vector checking for bad strips.

Beware of corner cases: what if all strips are bad?

the vector is empty? What if the last strip is bad and contiguous with the next group which is coming? What if its good and contiguous, but there are also some bad?

Definition at line 192 of file SCT_ClusteringTool.cxx.

                                                                                      {
 
    const unsigned int firstStripNumber(idHelper.strip(firstStripId));
    const unsigned int endStripNumber(firstStripNumber + nStrips); // one-past-the-end
    const Identifier   waferId(idHelper.wafer_id(firstStripId));
    IdentifierHash     waferHash( idHelper.wafer_hash(waferId) );
 
    clusterVector.reserve(clusterVector.size() + nStrips);
 
    static const Identifier badId;
    unsigned int nBadStrips(0);
    for (unsigned int stripNumber(firstStripNumber); stripNumber not_eq endStripNumber; ++stripNumber) {
      Identifier stripId(idHelper.strip_id(waferId, stripNumber));
      if (isBad(det_el_status, idHelper, waferHash, stripId, ctx)) {
        ++nBadStrips;
        stripId = badId;
      }
      clusterVector.push_back(stripId);
    }
 
    // Maybe all the strips are bad, clear the cluster vector
    if (clusterVector.size() == nBadStrips) {
      clusterVector.clear();
      // No need to recluster if vector is empty (same true if empty for other reasons)
      return;
    }
 
    // Now we have one vector of stripIds, some of which may be 'bad'
    if (nBadStrips != 0) {
 
      clusterVector=recluster(clusterVector, idGroups);
      // After this, the cluster vector is either empty or has the last good cluster
    }
  }

clusterDimensions()

SCT_ClusteringTool::DimensionAndPosition InDet::SCT_ClusteringTool::clusterDimensions ( int firstStrip, int lastStrip, const InDetDD::SiDetectorElement * element, const SCT_ID & idHelper )

staticprivate

Calculate the cluster position and width given the first and last strip numbers for this element.

Definition at line 765 of file SCT_ClusteringTool.cxx.

                                                         {  //since a range check on strip numbers was removed, idHelper is no longer needed here
    const int                      nStrips(lastStrip - firstStrip + 1);
    // Consider strips before and after (in case nStrips=1), both are guaranteed
    // to return sensible results, even for end strips
    const InDetDD::SiCellId        cell1(firstStrip - 1);
    const InDetDD::SiCellId        cell2(lastStrip + 1);
    const InDetDD::SiLocalPosition firstStripPos(pElement->rawLocalPositionOfCell(cell1));
    const InDetDD::SiLocalPosition lastStripPos(pElement->rawLocalPositionOfCell(cell2));
    const double                   width((static_cast<double>(nStrips)/static_cast<double>(nStrips+1))*( lastStripPos.xPhi()-firstStripPos.xPhi()));
    const InDetDD::SiLocalPosition centre((firstStripPos+lastStripPos)*0.5);
    return SCT_ClusteringTool::DimensionAndPosition(centre, width);
  }

clusterDimensionsInclRow()

SCT_ClusteringTool::DimensionAndPosition InDet::SCT_ClusteringTool::clusterDimensionsInclRow ( int firstStrip, int lastStrip, int row, const InDetDD::SiDetectorElement * element, const InDetDD::SCT_ModuleSideDesign * design )

staticprivate

Calculate the cluster position and width given the first,last strip, and row numbers for this element for ITk.

Definition at line 781 of file SCT_ClusteringTool.cxx.

                                                                                                                                    {
    const int                      nStrips(lastStrip - firstStrip + 1);
    const int firstStrip1D = design->strip1Dim(firstStrip, row);
    const int lastStrip1D = design->strip1Dim(lastStrip, row);
    const double stripPitch = design->stripPitch();
    const InDetDD::SiCellId        cell1(firstStrip1D);
    const InDetDD::SiCellId        cell2(lastStrip1D);
    const InDetDD::SiLocalPosition firstStripPos(pElement->rawLocalPositionOfCell(cell1));
    const InDetDD::SiLocalPosition lastStripPos(pElement->rawLocalPositionOfCell(cell2));
    const double                   width(nStrips*stripPitch);
    const InDetDD::SiLocalPosition centre((firstStripPos+lastStripPos)*0.5);
    return SCT_ClusteringTool::DimensionAndPosition(centre, width);
  }

clusterize()

SCT_ClusterCollection * InDet::SCT_ClusteringTool::clusterize ( const InDetRawDataCollection< SCT_RDORawData > & RDOs, const SCT_ID & idHelper, const InDet::SiDetectorElementStatus * sctDetElementStatus, SCTClusteringCache & cache, DataPool< SCT_Cluster > * dataItemsPool, const EventContext & ctx ) const

override

Clusterize method the SCT RDOs. This method is the main one of this class.

If clusters have been split due to bad strips, would require a whole lot of new logic to recalculate hitsInThirdTimeBin word - instead, just find when this is the case here, and set hitsInThirdTimeBin to zero later on

clusters had been split - recalculating HitsInThirdTimeBin too difficult to be worthwhile for this rare corner case..

Definition at line 306 of file SCT_ClusteringTool.cxx.

  {
    ATH_MSG_VERBOSE ("SCT_ClusteringTool::clusterize()");
 
    if (m_doFastClustering) return fastClusterize(collection, idHelper, sctDetElStatus, cache, dataItemsPool, ctx);
 
    SCT_ClusterCollection* nullResult(nullptr);
    if (collection.empty()) {
      ATH_MSG_DEBUG("Empty RDO collection");
      return nullResult;
    }
 
    // Make a copy of the collection for sorting (no need to sort if theres only one RDO)
    std::vector<const SCT_RDORawData*> collectionCopy(collection.begin(), collection.end());
    if (collection.size() not_eq 1) std::sort(collectionCopy.begin(), collectionCopy.end(), strip_less_than());
 
    // Vector of identifiers in a cluster (most likely is that there is one strip in the cluster)
    // Vector of clusters to make the cluster collection (most likely equal to collection size)
    cache.currentVector.clear();
    cache.idGroups.clear();
    cache.tbinGroups.clear();
    int n01X(0);
    int n11X(0);
    unsigned int previousStrip(0); // Should be ok?
    uint16_t hitsInThirdTimeBin(0);
    int stripCount(0);
    for (const SCT_RDORawData* pRawData: collectionCopy) {
      const Identifier      firstStripId(pRawData->identify());
      const unsigned int    nStrips(pRawData->getGroupSize());
      const int             thisStrip(idHelper.strip(firstStripId));
      const int             BEC(idHelper.barrel_ec(firstStripId));
      const int             layer(idHelper.layer_disk(firstStripId));
 
      // Flushes the vector every time a non-adjacent strip is found
      if (not adjacent(thisStrip, previousStrip) and not(cache.currentVector.empty())) {
        if (m_majority01X) {
          if (n01X >= n11X) {
            cache.idGroups.push_back(cache.currentVector);
          }
        } else {
          // Add this group to existing groups (and flush)
          cache.idGroups.push_back(cache.currentVector);
        }
        cache.currentVector.clear();
        n01X=0;
        n11X=0;
        cache.tbinGroups.push_back(hitsInThirdTimeBin);
        hitsInThirdTimeBin =0;
        stripCount = 0;
      }
 
      // Only use clusters with certain time bit patterns if m_timeBinStr set
      bool passTiming(true);
      bool pass01X(true);
      bool passX1X(true);
      const SCT3_RawData* pRawData3(dynamic_cast<const SCT3_RawData*>(pRawData));
      if (!pRawData3) {
        ATH_MSG_ERROR("Casting into SCT3_RawData failed. This is probably caused by use of an old RDO file.");
        return nullptr;
      }
      const int timeBin(pRawData3->getTimeBin());
      std::bitset<3> timePattern(static_cast<unsigned long>(timeBin));
      if (not m_timeBinStr.empty()) passTiming = testTimeBins(timeBin);
 
      passX1X = testTimeBinsX1X(pRawData3->getTimeBin());
      if (passX1X) pass01X = testTimeBins01X(pRawData3->getTimeBin());
      if (pass01X) n01X++;
      if (passX1X and (not pass01X)) n11X++;
      if (m_innermostBarrelX1X) {
        if ((BEC==0) and (layer==0) and passX1X) passTiming=true;
        else passTiming = pass01X;
      } else if (m_innertwoBarrelX1X) {
        if ((BEC==0) and (layer==0 or layer==1) and passX1X) passTiming=true;
        else passTiming = pass01X;
      }
 
      // Now we are either (a) pushing more contiguous strips onto an existing vector
      //                or (b) pushing a new set of ids onto an empty vector
      if (passTiming or m_majority01X) {
        if (m_useRowInformation) {
           addStripsToClusterInclRows(firstStripId, nStrips, cache.currentVector, cache.idGroups, idHelper,sctDetElStatus, ctx); // Note this takes the current vector only
        } else if (not m_checkBadChannels) {
          addStripsToCluster(firstStripId, nStrips, cache.currentVector, idHelper); // Note this takes the current vector only
        } else {
          addStripsToClusterWithChecks(firstStripId, nStrips, cache.currentVector, cache.idGroups, idHelper,sctDetElStatus, ctx); // This one includes the groups of vectors as well
        }
        for (unsigned int iStrip=0; iStrip<nStrips; iStrip++) {
          if (stripCount < 16) hitsInThirdTimeBin |= (timePattern.test(0) << stripCount);
          stripCount++;
        }
      }
      if (not cache.currentVector.empty()) {
        // Gives the last strip number in the cluster
        previousStrip = idHelper.strip(cache.currentVector.back());
      }
    }
 
    // Still need to add this last vector
    if (not cache.currentVector.empty()) {
      if ((not m_majority01X) or (n01X >= n11X)) {
        cache.idGroups.push_back(cache.currentVector);
        cache.tbinGroups.push_back(hitsInThirdTimeBin);
        hitsInThirdTimeBin=0;
      }
    }
 
    // Find detector element for these digits
    const Identifier elementID(collection.identify());
    const Identifier waferId{idHelper.wafer_id(elementID)};
    const IdentifierHash waferHash{idHelper.wafer_hash(waferId)};
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEleHandle(m_SCTDetEleCollKey, ctx);
    const InDetDD::SiDetectorElementCollection* sctDetEle(*sctDetEleHandle);
    if (not sctDetEleHandle.isValid() or sctDetEle==nullptr) {
      ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " is not available.");
      return nullResult;
    }
    const InDetDD::SiDetectorElement* element(sctDetEle->getDetectorElement(waferHash));
    if (!element) {
      ATH_MSG_WARNING("Element not in the element map, ID = "<< elementID);
      return nullResult;
    }
 
    const InDetDD::SCT_ModuleSideDesign* design;
    if (idHelper.is_barrel(elementID)) {
      design = (static_cast<const InDetDD::SCT_BarrelModuleSideDesign*>(&element->design()));
    } else {
      design = (static_cast<const InDetDD::SCT_ForwardModuleSideDesign*>(&element->design()));
    }
 
    IdentifierHash idHash(collection.identifyHash());
    SCT_ClusterCollection* clusterCollection = new SCT_ClusterCollection(idHash);
    clusterCollection->setIdentifier(elementID);
    clusterCollection->reserve(cache.idGroups.size());
    //DataPool will own the elements
    if(dataItemsPool){
      clusterCollection->clear(SG::VIEW_ELEMENTS);
    }
 
    // All strips are assumed to be the same width.
    std::vector<uint16_t>::iterator tbinIter(cache.tbinGroups.begin());

    const bool badStripInClusterOnThisModuleSide = (cache.idGroups.size() != cache.tbinGroups.size());
 
    for (IdVec_t& stripGroup: cache.idGroups) {
      const int nStrips(stripGroup.size());
      if (nStrips == 0) continue;
      //
      const InDetDD::SiLocalPosition dummyPos(1, 0);
      DimensionAndPosition clusterDim(dummyPos, 1.0);//just initialize with arbitrary values, will be set properly in the next two lines...
      if (m_useRowInformation) clusterDim = clusterDimensionsInclRow(idHelper.strip(stripGroup.front()), idHelper.strip(stripGroup.back()), idHelper.row(stripGroup.front()), element, design);
      else clusterDim = clusterDimensions(idHelper.strip(stripGroup.front()), idHelper.strip(stripGroup.back()), element, idHelper);
      const Amg::Vector2D localPos(clusterDim.centre.xPhi(), clusterDim.centre.xEta());
      // Since clusterId is arbitary (it only needs to be unique) just use ID of first strip
      //const Identifier clusterId = element->identifierOfPosition(clusterDim.centre);
      const Identifier clusterId(stripGroup.front());
      if (!clusterId.is_valid()) ATH_MSG_VERBOSE(clusterId << " is invalid.");
      //
      // Find length of strip at centre
      const std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends(design->endsOfStrip(clusterDim.centre));
      const double stripLength(std::abs(ends.first.xEta()-ends.second.xEta()));
      //
      // Now make a SiCluster
      const SiWidth siWidth(Amg::Vector2D(nStrips, 1), Amg::Vector2D(clusterDim.width, stripLength));
 
      SCT_Cluster* cluster = nullptr;
      if (dataItemsPool){
         cluster =  dataItemsPool->nextElementPtr();
      }else{
        cluster = new SCT_Cluster();
      }
 
      (*cluster) =
          (m_clusterMaker)
              ? (m_clusterMaker->sctCluster(clusterId, localPos, std::move(stripGroup),
                                            siWidth, element, m_errorStrategy))
              : (SCT_Cluster(clusterId, localPos, std::move(stripGroup), siWidth, element,
                             {}));
 
      cluster->setHashAndIndex(clusterCollection->identifyHash(),
                               clusterCollection->size());
      if (tbinIter != cache.tbinGroups.end()) {
        cluster->setHitsInThirdTimeBin(*tbinIter);
        ++tbinIter;
      }
      if (badStripInClusterOnThisModuleSide) cluster->setHitsInThirdTimeBin(0);
      clusterCollection->push_back(cluster);
    }
 
    return clusterCollection;
  }

decodeTimeBin()

StatusCode InDet::SCT_ClusteringTool::decodeTimeBin ( char timeBin, int & bit ) const

private

Convert a single time bin char to an int, bit is modified.

Definition at line 82 of file SCT_ClusteringTool.cxx.

                                                                           {
    // Decode individual time char
    if (timeBin == 'X') {bit = -1; return StatusCode::SUCCESS;}
    if (timeBin == '0') {bit =  0; return StatusCode::SUCCESS;}
    if (timeBin == '1') {bit =  1; return StatusCode::SUCCESS;}
 
    ATH_MSG_FATAL("Invalid time bin string " << timeBin);
    return StatusCode::FAILURE;
  }

decodeTimeBins()

StatusCode InDet::SCT_ClusteringTool::decodeTimeBins ( )

private

Convert time bin string to array of 3 bits.

Definition at line 60 of file SCT_ClusteringTool.cxx.

                                                {
    // Decode time bins from string of form e.g. "01X" to integer bits (-1 means X)
    m_timeBinBits[0] = -1;
    m_timeBinBits[1] = -1;
    m_timeBinBits[2] = -1;
 
    if (m_timeBinStr.empty()) return StatusCode::SUCCESS;
    if (m_timeBinStr.size() != 3) {
      ATH_MSG_FATAL("Time bin string must only contain 3 bins");
      return StatusCode::FAILURE;
    }
    std::transform(m_timeBinStr.begin(), m_timeBinStr.end(), m_timeBinStr.begin(), ::toupper);
 
    for (unsigned int i(0); i<m_timeBinStr.size(); ++i) {
      int timeBin(-999);
      if (decodeTimeBin(m_timeBinStr[i], timeBin).isFailure()) return StatusCode::FAILURE;
      m_timeBinBits[i] = timeBin;
    }
 
    return StatusCode::SUCCESS;
  }

fastClusterize()

SCT_ClusterCollection * InDet::SCT_ClusteringTool::fastClusterize	(	const InDetRawDataCollection< SCT_RDORawData > &	RDOs,
		const SCT_ID &	idHelper,
		const InDet::SiDetectorElementStatus *	sctDetElementStatus,
		SCTClusteringCache &	cache,
		DataPool< SCT_Cluster > *	dataItemsPool,
		const EventContext &	ctx ) const

A new fast method originally implemented for ITk.

Can be internally used in clusterize with m_doFastClustering=true.

Definition at line 506 of file SCT_ClusteringTool.cxx.

  {
    if (collection.empty()) return nullptr;
 
    std::vector<const SCT_RDORawData*> collectionCopy(collection.begin(), collection.end());
 
    if (collectionCopy.size() > 1) std::sort(collectionCopy.begin(), collectionCopy.end(), strip_less_than());
 
    cache.currentVector.clear();
    cache.idGroups.clear();
    cache.tbinGroups.clear();
 
    unsigned int previousStrip = 0; // Should be ok?
    uint16_t hitsInThirdTimeBin = 0;
    int stripCount  =  0;
    int previousRow = -1;
    int thisRow     = -1;
 
    const Identifier badId;
 
    for (const SCT_RDORawData* pRawData: collectionCopy) {
      Identifier firstStripId = pRawData->identify();
      Identifier waferId = idHelper.wafer_id(firstStripId);
      IdentifierHash waferHash = idHelper.wafer_hash(waferId);
      unsigned int nStrips = pRawData->getGroupSize();
      int thisStrip = idHelper.strip(firstStripId);
 
      if (m_useRowInformation) thisRow = idHelper.row(firstStripId);
 
      // Flushes the vector every time a non-adjacent strip is found
      //
      if (not cache.currentVector.empty() and
          ((m_useRowInformation and !adjacent(thisStrip, thisRow, previousStrip, previousRow)) or
           (not m_useRowInformation and !adjacent(thisStrip, previousStrip)))) {
 
        // Add this group to existing groups (and flush)
        //
        cache.idGroups.push_back(cache.currentVector);
        cache.currentVector.clear();
 
        cache.tbinGroups.push_back(hitsInThirdTimeBin);
        hitsInThirdTimeBin = 0;
        stripCount         = 0;
      }
 
      // Only use clusters with certain time bit patterns if m_timeBinStr set
 
      const SCT3_RawData* pRawData3 = dynamic_cast<const SCT3_RawData*>(pRawData);
      //sroe: coverity 31562
      if (!pRawData3) {
        ATH_MSG_ERROR("Casting into SCT3_RawData failed. This is probably caused by use of an old RDO file.");
        return nullptr;
      }
 
      int timeBin = pRawData3->getTimeBin();
      std::bitset<3> timePattern(static_cast<unsigned long>(timeBin));
 
      bool passTiming = true;
 
      if (!m_timeBinStr.empty()) passTiming = testTimeBinsN(timePattern);
 
      // Now we are either (a) pushing more contiguous strips onto an existing vector
      //                or (b) pushing a new set of ids onto an empty vector
      //
      if (passTiming) {
        unsigned int nBadStrips(0);
        unsigned int max_strip = std::min( static_cast<unsigned int>(thisStrip+nStrips), static_cast<unsigned int>(idHelper.strip_max(waferId)+1) );
 
        if (thisStrip+nStrips > max_strip) {
           ATH_MSG_DEBUG("SCT strip range exceeds bounds: strip range " << thisStrip << " .. + " << nStrips << " = " << (thisStrip+nStrips)
               << " !<= " << max_strip );
        }
        for (unsigned int sn=thisStrip; sn < max_strip; ++sn) {
          Identifier stripId = m_useRowInformation ? idHelper.strip_id(waferId,thisRow,sn) : idHelper.strip_id(waferId,sn);
          if (!isBad(sctDetElStatus, idHelper, waferHash, stripId, ctx)) {
            cache.currentVector.push_back(stripId);
          } else {
            cache.currentVector.push_back(badId);
            ++nBadStrips;
          }
          if (stripCount < 16) {
            hitsInThirdTimeBin = hitsInThirdTimeBin | (timePattern.test(0) << stripCount);
          }
          ++stripCount;
        }
 
        if (cache.currentVector.size() == nBadStrips) {
          cache.currentVector.clear();
        } else if (nBadStrips) {
          cache.currentVector=recluster(cache.currentVector, cache.idGroups);
        }
      }
 
      if (not cache.currentVector.empty()) {
        // Gives the last strip number in the cluster
        //
        previousStrip = idHelper.strip(cache.currentVector.back());
        if (m_useRowInformation) previousRow = idHelper.row(cache.currentVector.back());
      }
    }
 
    // Still need to add this last vector
    //
    if (not cache.currentVector.empty()) {
      cache.idGroups.push_back(cache.currentVector);
      cache.tbinGroups.push_back(hitsInThirdTimeBin);
      hitsInThirdTimeBin=0;
    }
 
    // Find detector element for these digits
    //
    IdentifierHash idHash = collection.identifyHash();
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEleHandle(m_SCTDetEleCollKey, ctx);
    const InDetDD::SiDetectorElementCollection* sctDetEle(*sctDetEleHandle);
    if (not sctDetEleHandle.isValid() or sctDetEle==nullptr) {
      ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " is not available.");
      return nullptr;
    }
    const InDetDD::SiDetectorElement* element(sctDetEle->getDetectorElement(idHash));
    if (!element) {
      ATH_MSG_WARNING("Element not in the element map, hash = " << idHash);
      return nullptr;
    }
 
    const InDetDD::SCT_ModuleSideDesign* design = (dynamic_cast<const InDetDD::SCT_ModuleSideDesign*>(&element->design()));
    if(design==nullptr) return nullptr;
 
    SCT_ClusterCollection* clusterCollection = new SCT_ClusterCollection(idHash);
    Identifier elementID = collection.identify();
    clusterCollection->setIdentifier(elementID);
    clusterCollection->reserve(cache.idGroups.size());
    if(dataItemsPool){
      clusterCollection->clear(SG::VIEW_ELEMENTS);
    }
 
    int clusterNumber = 0;
 
    // All strips are assumed to be the same width.
    //
    std::vector<IdVec_t>::iterator pGroup = cache.idGroups.begin();
    std::vector<IdVec_t>::iterator lastGroup = cache.idGroups.end();
    std::vector<uint16_t>::iterator tbinIter = cache.tbinGroups.begin();
 
    // If clusters have been split due to bad strips, would require a whole lot
    // of new logic to recalculate hitsInThirdTimeBin word - instead, just find
    // when this is the case here, and set hitsInThirdTimeBin to zero later on
    //
    double iphipitch  = 1./element->phiPitch();
    double shift = m_lorentzAngleTool->getLorentzShift(idHash,ctx);
    double stripPitch = design->stripPitch();
    bool badStripInClusterOnThisModuleSide = (cache.idGroups.size() != cache.tbinGroups.size());
    bool rotate = (element->design().shape() == InDetDD::Trapezoid || element->design().shape() == InDetDD::Annulus);
    double stripL = 0.;
    double COV11 = 0.;
 
    if (not rotate) {
      stripL = design->etaPitch();
      COV11 = stripL*stripL*(1./12.);
    }
 
    for (; pGroup!=lastGroup; ++pGroup) {
      int nStrips = pGroup->size();
      double dnStrips = static_cast<double>(nStrips);
      Identifier clusterId = pGroup->front();
 
      int firstStrip = idHelper.strip(clusterId);
      double width = stripPitch;
      InDetDD::SiLocalPosition centre;
      if (m_useRowInformation || m_doSimplePosWidth) {
        int row = idHelper.row(clusterId); //This is always 0 - should consider dropping
        centre = element->rawLocalPositionOfCell(design->strip1Dim(firstStrip, row));
        if (nStrips > 1) {
          InDetDD::SiLocalPosition lastStripPos(element->rawLocalPositionOfCell(design->strip1Dim(firstStrip+nStrips-1, row)));
          centre = (centre+lastStripPos)*.5;
          width *=dnStrips;
        }
      } else {
        DimensionAndPosition clusterDim = clusterDimensions(idHelper.strip(pGroup->front()), idHelper.strip(pGroup->back()), element, idHelper);
        centre = clusterDim.centre;
        width  = clusterDim.width;
      }
 
      Amg::Vector2D localPos{centre.xPhi(), centre.xEta()};
      Amg::Vector2D locpos{centre.xPhi()+shift, centre.xEta()};
 
      // Now make a SiCluster
      //
      double x = 0.;
      // single strip - resolution close to pitch/sqrt(12)
      // two-strip hits: better resolution, approx. 40% lower
      // lines taken from ClusterMakerTool::sctCluster
      if (nStrips == 1) {
        x = 1.05*width;
      } else {
        if (nStrips == 2) {
          x = 0.27*width;
        } else {
          x = width;
        }
      }
 
      double V[4] = {x*x*(1./12.), 0., 0., COV11};
 
      if (rotate) {
        // Find length of strip at centre
        //
        std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends(design->endsOfStrip(centre));
        stripL = std::abs(ends.first.xEta()-ends.second.xEta());
 
        double w       = element->phiPitch(localPos)*iphipitch;
        double sn      = element->sinStereoLocal(localPos);
        double sn2     = sn*sn;
        double cs2     = 1.-sn2;
        double v0      = V[0]*w*w;
        double v1      = stripL*stripL*(1./12.);
        V[0]           = cs2*v0+sn2*v1;
        V[1]  =  V[2]  = sn*sqrt(cs2)*(v0-v1);
        V[3]           = sn2*v0+cs2*v1;
      }
 
      auto errorMatrix = Amg::MatrixX(2,2);
      errorMatrix<<V[0],V[1],V[2],V[3];
 
      SiWidth siWidth{Amg::Vector2D(dnStrips,1.), Amg::Vector2D(width,stripL)};
 
      SCT_Cluster* cluster = nullptr;
      if (dataItemsPool) {
        cluster = dataItemsPool->nextElementPtr();
        (*cluster) = SCT_Cluster{clusterId, locpos,  std::move(*pGroup),
                                 siWidth,   element, std::move(errorMatrix)};
 
      } else {
        cluster = new SCT_Cluster{clusterId, locpos,  std::move(*pGroup),
                                  siWidth,   element, std::move(errorMatrix)};
      }
 
      cluster->setHashAndIndex(idHash, clusterNumber);
 
      if (tbinIter != cache.tbinGroups.end()) {
        cluster->setHitsInThirdTimeBin(*tbinIter);
        ++tbinIter;
      }
 
      // clusters had been split - recalculating HitsInThirdTimeBin too difficult to be worthwhile for this rare corner case..
      //
      if (badStripInClusterOnThisModuleSide) cluster->setHitsInThirdTimeBin(0);
 
      clusterCollection->push_back(cluster);
      clusterNumber++;
    }
    return clusterCollection;
  }

initialize()

StatusCode InDet::SCT_ClusteringTool::initialize ( )

overridevirtual

Retrieve the necessary services in initialize.

only one of m_majority01X, m_innermostBarrelX1X and m_innertwoBarrelX1X can be true - check if this is the case If none of them is true, m_timeBinStr is used.

Definition at line 124 of file SCT_ClusteringTool.cxx.

                                            {
    ATH_CHECK(m_clusterMaker.retrieve());
 
    if (m_checkBadChannels && m_sctDetElStatus.empty()) {
      ATH_MSG_DEBUG("Clustering has been asked to look at bad channel info");
      ATH_CHECK(m_conditionsTool.retrieve());
    } else {
      m_conditionsTool.disable();
    }
 
    if (m_doFastClustering and not m_lorentzAngleTool.empty()) {
      ATH_CHECK(m_lorentzAngleTool.retrieve());
    } else {
      m_lorentzAngleTool.disable();
    }
 
    if (decodeTimeBins().isFailure()) return StatusCode::FAILURE;

    int countTrueSettings(0);
    if (m_majority01X) countTrueSettings++;
    if (m_innermostBarrelX1X) countTrueSettings++;
    if (m_innertwoBarrelX1X) countTrueSettings++;
    if (countTrueSettings!=1) {
      if (!m_timeBinStr.empty()) {
        ATH_MSG_DEBUG("Timing requirement: m_timeBinStr " << m_timeBinStr << " is used for clustering");
      } else {
        if (countTrueSettings==0) {
          ATH_MSG_DEBUG("Timing requirement is not used for clustering");
        } else {
          ATH_MSG_FATAL("One and only one of m_majority01X, m_innermostBarrelX1X and m_innertwoBarrelX1X should be set to True!");
          return StatusCode::FAILURE;
        }
      }
    } else {
      ATH_MSG_DEBUG("Timing requirement: " <<
                   (m_majority01X        ? "m_majority01X"        : "") <<
                   (m_innermostBarrelX1X ? "m_innermostBarrelX1X" : "") <<
                   (m_innertwoBarrelX1X  ? "m_innertwoBarrelX1X"  : "") <<
                   " is true and used for clustering");
    }
 
    ATH_CHECK(m_SCTDetEleCollKey.initialize());
    ATH_CHECK(m_sctDetElStatus.initialize( !m_sctDetElStatus.empty()) );
 
    return StatusCode::SUCCESS;
  }

isBad()

bool InDet::SCT_ClusteringTool::isBad ( const InDet::SiDetectorElementStatus * sctDetElStatus, const SCT_ID & sctID, const IdentifierHash & waferHash, const Identifier & stripId, const EventContext & ctx ) const

inlineprivate

In-class facade on the 'isGood' method for a strip identifier.

Definition at line 204 of file SCT_ClusteringTool.h.

                                   {
  if (sctDetElStatus) {
    const int strip_i{sctID.strip(stripId)};
    VALIDATE_STATUS_ARRAY(
        sctDetElStatus, sctDetElStatus->isCellGood(waferHash.value(), strip_i),
        m_conditionsTool->isGood(stripId, InDetConditions::SCT_STRIP, ctx));
    return !sctDetElStatus->isCellGood(waferHash.value(), strip_i);
  } else {
    return (
        not m_conditionsTool->isGood(stripId, InDetConditions::SCT_STRIP, ctx));
  }
}

recluster()

SCT_ClusteringTool::IdVec_t InDet::SCT_ClusteringTool::recluster ( SCT_ClusteringTool::IdVec_t & clusterVector, std::vector< IdVec_t > & idGroups ) const

private

Recluster the current vector, splitting on bad strips, and insert those new groups to the idGroups vector.

recluster starts with a vector of Ids, some of which may be invalid due to them being bad strips, and a vector of these vectors.

The cluster vector referenced will be changed by this, as well as the idGroups

We recursively split the original clustervector, adding to idGroups as we go. It should eventually either return an empty cluster or a cluster of all good strips, to be inserted by the caller.

Definition at line 279 of file SCT_ClusteringTool.cxx.

                                                                                                                  {
 
    // Default Identifier constructor gives a sentinel value
    static const Identifier invalidId;
    const unsigned int numberOfBadStrips(std::count(clusterVector.begin(), clusterVector.end(), invalidId));
 
    // All the strips are good, return the original vector to be put in idGroups by the caller
    if (numberOfBadStrips==0 or clusterVector.empty()) return clusterVector;
    // All the strips are bad, clear the vector and return it
    if (clusterVector.size() == numberOfBadStrips) {
      clusterVector.clear();
      return clusterVector;
    }
 
    // Pointer to first bad strip
    SCT_ClusteringTool::IdVec_t::iterator pBadId(std::find(clusterVector.begin(), clusterVector.end(), invalidId));
    // Make a new cluster, which could be empty, if the first strip is bad
    SCT_ClusteringTool::IdVec_t subCluster(clusterVector.begin(), pBadId);
    // Remove elements including the badId
    if (pBadId != clusterVector.end()) clusterVector.erase(clusterVector.begin(), ++pBadId);
    if (not subCluster.empty()) idGroups.push_back(subCluster);
    return recluster(clusterVector, idGroups);
  }

testTimeBins()

bool InDet::SCT_ClusteringTool::testTimeBins ( int timeBin ) const

private

Definition at line 92 of file SCT_ClusteringTool.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
 
    const std::bitset<3> timePattern(static_cast<unsigned long>(timeBin));
    return testTimeBinsN(timePattern);
  }

testTimeBins01X()

bool InDet::SCT_ClusteringTool::testTimeBins01X ( int timeBin )

staticprivate

Definition at line 101 of file SCT_ClusteringTool.cxx.

                                                      {
    // Convert the given timebin to a bit set and test each bit
    // if bit is -1 (i.e. X) it always passes, otherwise require exact match of 0/1
    // N.B bitset has opposite order to the bit pattern we define
 
    bool pass(true);
    const std::bitset<3> timePattern(static_cast<unsigned long>(timeBin));
    if (timePattern.test(2)) pass=false;
    if (!timePattern.test(1)) pass=false;
    return pass;
  }

testTimeBinsN()

bool InDet::SCT_ClusteringTool::testTimeBinsN ( const std::bitset< 3 > & timePattern ) const

inlineprivate

Definition at line 220 of file SCT_ClusteringTool.h.

                                           {
  // 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;
}

testTimeBinsX1X()

bool InDet::SCT_ClusteringTool::testTimeBinsX1X ( int timeBin )

staticprivate

Definition at line 113 of file SCT_ClusteringTool.cxx.

                                                      {
    // Convert the given timebin to a bit set and test each bit
    // if bit is -1 (i.e. X) it always passes, otherwise require exact match of 0/1
    // N.B bitset has opposite order to the bit pattern we define
 
    bool pass(true);
    const std::bitset<3> timePattern(static_cast<unsigned long>(timeBin));
    if (!timePattern.test(1)) pass=false;
    return pass;
  }

Member Data Documentation

m_checkBadChannels

BooleanProperty InDet::SCT_ClusteringTool::m_checkBadChannels {this, "checkBadChannels", true}

private

Definition at line 101 of file SCT_ClusteringTool.h.

{this, "checkBadChannels", true};

m_clusterMaker

ToolHandle<ClusterMakerTool> InDet::SCT_ClusteringTool::m_clusterMaker

private

Initial value:

{this, "globalPosAlg",
                                              "InDet::ClusterMakerTool"}

Definition at line 89 of file SCT_ClusteringTool.h.

                                             {this, "globalPosAlg",
                                              "InDet::ClusterMakerTool"};

m_conditionsTool

ToolHandle<IInDetConditionsTool> InDet::SCT_ClusteringTool::m_conditionsTool

private

Initial value:

{
      this, "conditionsTool",
      "SCT_ConditionsSummaryTool/InDetSCT_ConditionsSummaryTool",
      "Tool to retrieve SCT Conditions summary"}

Definition at line 85 of file SCT_ClusteringTool.h.

                                                   {
      this, "conditionsTool",
      "SCT_ConditionsSummaryTool/InDetSCT_ConditionsSummaryTool",
      "Tool to retrieve SCT Conditions summary"};

m_doFastClustering

BooleanProperty InDet::SCT_ClusteringTool::m_doFastClustering {this, "doFastClustering", true}

private

Definition at line 107 of file SCT_ClusteringTool.h.

{this, "doFastClustering", true};

m_doSimplePosWidth

BooleanProperty InDet::SCT_ClusteringTool::m_doSimplePosWidth {this, "doSimplePositionWidthCalculation", false, "Always use the simpler position and width calculation in fast clustering"}

private

Definition at line 108 of file SCT_ClusteringTool.h.

{this, "doSimplePositionWidthCalculation", false, "Always use the simpler position and width calculation in fast clustering"};

m_errorStrategy

IntegerProperty InDet::SCT_ClusteringTool::m_errorStrategy {this, "errorStrategy", 1}

private

Definition at line 100 of file SCT_ClusteringTool.h.

{this, "errorStrategy", 1};

m_innermostBarrelX1X

BooleanProperty InDet::SCT_ClusteringTool::m_innermostBarrelX1X {this, "innermostBarrelX1X", false}

private

Definition at line 103 of file SCT_ClusteringTool.h.

{this, "innermostBarrelX1X", false};

m_innertwoBarrelX1X

BooleanProperty InDet::SCT_ClusteringTool::m_innertwoBarrelX1X {this, "innertwoBarrelX1X", false}

private

Definition at line 104 of file SCT_ClusteringTool.h.

{this, "innertwoBarrelX1X", false};

m_lorentzAngleTool

ToolHandle<ISiLorentzAngleTool> InDet::SCT_ClusteringTool::m_lorentzAngleTool

private

Initial value:

{
      this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool",
      "Tool to retreive Lorentz angle of SCT"}

Definition at line 91 of file SCT_ClusteringTool.h.

                                                    {
      this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool",
      "Tool to retreive Lorentz angle of SCT"};

m_majority01X

BooleanProperty InDet::SCT_ClusteringTool::m_majority01X {this, "majority01X", false}

private

Definition at line 105 of file SCT_ClusteringTool.h.

{this, "majority01X", false};

m_SCTDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> InDet::SCT_ClusteringTool::m_SCTDetEleCollKey

private

Initial value:

{this, "SCTDetEleCollKey",
                         "SCT_DetectorElementCollection",
                         "Key of SiDetectorElementCollection for SCT. "
                         "Necessary for alignment"}

Definition at line 116 of file SCT_ClusteringTool.h.

                        {this, "SCTDetEleCollKey",
                         "SCT_DetectorElementCollection",
                         "Key of SiDetectorElementCollection for SCT. "
                         "Necessary for alignment"};

m_sctDetElStatus

SG::ReadHandleKey<InDet::SiDetectorElementStatus> InDet::SCT_ClusteringTool::m_sctDetElStatus

private

Initial value:

{
      this, "SCTDetElStatus", "", "Key of SiDetectorElementStatus for SCT"}

Optional read handle to get status data to test whether a SCT detector element is good.

If set to e.g. SCTDetectorElementStatus the event data will be used instead of the SCT conditions summary tool.

Definition at line 125 of file SCT_ClusteringTool.h.

                                                                {
      this, "SCTDetElStatus", "", "Key of SiDetectorElementStatus for SCT"};

m_timeBinBits

int InDet::SCT_ClusteringTool::m_timeBinBits[3] {-1, -1, -1}

private

Time bin bits for timing requirement.

Set by decodeTimeBins() in initialize().

Definition at line 130 of file SCT_ClusteringTool.h.

{-1, -1, -1};

m_timeBinStr

StringProperty InDet::SCT_ClusteringTool::m_timeBinStr {this, "timeBins", ""}

private

Definition at line 102 of file SCT_ClusteringTool.h.

{this, "timeBins", ""};

m_useRowInformation

BooleanProperty InDet::SCT_ClusteringTool::m_useRowInformation {this, "useRowInformation", false}

private

Definition at line 106 of file SCT_ClusteringTool.h.

{this, "useRowInformation", false};

---

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

• SCT_ClusteringTool.h
• SCT_ClusteringTool.cxx