HGTD::SinglePadClusterTool Class Reference

#include <SinglePadClusterTool.h>

Inheritance diagram for HGTD::SinglePadClusterTool:

Collaboration diagram for HGTD::SinglePadClusterTool:

Public Member Functions
	SinglePadClusterTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override final
virtual std::unique_ptr< HGTD_ClusterCollection >	clusterize (const HGTD_RDO_Collection &rdo_coll, DataPool< HGTD_Cluster > *dataItemsPool) const override final

Private Attributes
ToolHandle< HGTD_ClusterMakerTool >	m_cluster_maker {this, "ClusterMakerTool", "HGTD_ClusterMakerTool", "Tool for creating HGTD_Cluster objects"}
const HGTD_DetectorManager *	m_hgtd_det_mgr {nullptr}

Detailed Description

Definition at line 28 of file SinglePadClusterTool.h.

Constructor & Destructor Documentation

SinglePadClusterTool()

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

Definition at line 17 of file SinglePadClusterTool.cxx.

    : base_class(type, name, parent) {}

Member Function Documentation

clusterize()

std::unique_ptr< HGTD_ClusterCollection > HGTD::SinglePadClusterTool::clusterize ( const HGTD_RDO_Collection & rdo_coll, DataPool< HGTD_Cluster > * dataItemsPool ) const

finaloverridevirtual

Definition at line 34 of file SinglePadClusterTool.cxx.

                                                                              {
 
  Identifier identifier = rdo_coll.identify();
  IdentifierHash id_hash = rdo_coll.identifierHash();
 
  std::unique_ptr<HGTD_ClusterCollection> cluster_collection =
      std::make_unique<HGTD_ClusterCollection>(id_hash);
 
  if(dataItemsPool){
      cluster_collection->clear(SG::VIEW_ELEMENTS);
  }
 
  cluster_collection->setIdentifier(identifier);
  cluster_collection->reserve(rdo_coll.size());
 
  const InDetDD::HGTD_DetectorElement* element =
      m_hgtd_det_mgr->getDetectorElement(identifier);
 
  for (const auto *const rdo : rdo_coll) {
 
    Identifier rdo_id = rdo->identify();
    ATH_MSG_DEBUG("Using RDO: " << rdo_id);
 
    // get the local position from the detector design
    InDetDD::SiCellId si_cell_id = element->cellIdFromIdentifier(rdo_id);
    const InDetDD::HGTD_ModuleDesign& det_design = element->design();
    InDetDD::SiLocalPosition si_pos =
        det_design.localPositionOfCell(si_cell_id);
    Amg::Vector2D loc_pos(si_pos.xPhi(), si_pos.xEta());
    ATH_MSG_DEBUG("Local position: x=" << loc_pos.x() << " y=" << loc_pos.y());
 
    // a cluster consists only of the pad itself
    std::vector<Identifier> rdo_list = {rdo_id};
 
    // From SiWidth header:
    // Constructor with parameters: <col, row> in units of RDOs (so should be
    // int),
    //                              <phiR width in mm, Z width in mm>
    // NOTE: without a clustering of the pads, the width of each "cluster" is 1
    // in col and row direction
    int col_width = 1;
    int row_width = 1;
    //FIXME there is a bug in the detector design! should not be hardcoded here
    // double eta_width = det_design.etaPitch();
    // double phi_width = det_design.phiPitch();
    double eta_width = 1.3;
    double phi_width = 1.3;
    ATH_MSG_DEBUG("eta_width=" << eta_width << " phi_width=" << phi_width);
 
    InDet::SiWidth si_width(Amg::Vector2D(col_width, row_width),
                            Amg::Vector2D(phi_width, eta_width));
 
    // retrieve the time of arrival
    float time_of_arrival = rdo->getTOA();
 
    // this would hold the vector of all cluster components. Only size 1 if RDO
    // gets transformed to cluster directly
    std::vector<int> time_over_threshold = {static_cast<int>(rdo->getTOT())};
 
    HGTD_Cluster* cluster = nullptr;
    if (dataItemsPool) {
      // data Item pool owns the element. The collection
      // is view. Just move assign to it.
      cluster = dataItemsPool->nextElementPtr();
   } else {
      // collection will own the element release
      cluster = new HGTD_Cluster();
    }
    (*cluster) = m_cluster_maker->createCluster(
        rdo_id,
        loc_pos,
        std::move(rdo_list),
        si_width,
        element,
        time_of_arrival,
        std::move(time_over_threshold));
 
   cluster->setHashAndIndex(cluster_collection->identifyHash(),
                             cluster_collection->size());
 
    cluster_collection->push_back(cluster);
  }
  return cluster_collection;
}

initialize()

StatusCode HGTD::SinglePadClusterTool::initialize ( )

finaloverridevirtual

Definition at line 22 of file SinglePadClusterTool.cxx.

                                            {
 
  ATH_CHECK(AlgTool::initialize());
 
  ATH_CHECK(m_cluster_maker.retrieve());
 
  ATH_CHECK(detStore()->retrieve(m_hgtd_det_mgr, "HGTD"));
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_cluster_maker

ToolHandle<HGTD_ClusterMakerTool> HGTD::SinglePadClusterTool::m_cluster_maker {this, "ClusterMakerTool", "HGTD_ClusterMakerTool", "Tool for creating HGTD_Cluster objects"}

private

Definition at line 41 of file SinglePadClusterTool.h.

{this, "ClusterMakerTool", "HGTD_ClusterMakerTool", "Tool for creating HGTD_Cluster objects"};

m_hgtd_det_mgr

const HGTD_DetectorManager* HGTD::SinglePadClusterTool::m_hgtd_det_mgr {nullptr}

private

Definition at line 42 of file SinglePadClusterTool.h.

{nullptr};

---

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

• SinglePadClusterTool.h
• SinglePadClusterTool.cxx