#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.

20 : 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());
  
   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.

◆ m_hgtd_det_mgr

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