This class reconstructs clusters of pixels. More...

#include <AFPSiClusterTool.h>

Inheritance diagram for AFPSiClusterTool:

Collaboration diagram for AFPSiClusterTool:

Public Member Functions
	AFPSiClusterTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual	~AFPSiClusterTool () override

virtual StatusCode	initialize () override

virtual StatusCode	finalize () override
	does nothing More...

StatusCode	clusterHits (std::unique_ptr< xAOD::AFPSiHitsClusterContainer > &clustr, const EventContext &ctx) const override
	Run clusters reconstruction. More...

Private Member Functions
StatusCode	clearAllLayers (std::vector< std::vector< AFPSiClusterLayerBasicObj > > &my_layers) const
	Runs AFPSiClusterLayerBasicObj::clearHitsAndClusters() on all layers in #my_layers. More...

StatusCode	fillLayersWithHits (std::vector< std::vector< AFPSiClusterLayerBasicObj > > &my_layers, const EventContext &ctx) const
	Reads hits from StoreGate and saves them to appropriate layers in #my_layers. More...

StatusCode	clusterEachLayer (std::vector< std::vector< AFPSiClusterLayerBasicObj > > &my_layers) const
	Runs tool reconstructing clusters on each layer. More...

StatusCode	saveToXAOD (std::unique_ptr< xAOD::AFPSiHitsClusterContainer > &clustr, std::vector< std::vector< AFPSiClusterLayerBasicObj > > &my_layers, const EventContext &ctx) const
	Save clusters in xAOD::AFPSiHitsClusterContainer. More...

std::vector< std::vector< AFPSiClusterLayerBasicObj > >	initLayers (const std::vector< int > &layersInStations) const
	Initialise size as well as station and layer ID for #my_layers. More...

Private Attributes
SG::ReadHandleKey< xAOD::AFPSiHitContainer >	m_AFPSiHitContainerKey { this, "AFPSiHitsContainerName", "AFPSiHitContainer", "name of AFPSiHit container" }

ToolHandle< IAFPSiClusterAlgTool >	m_clusterAlgToolHandle {this,"clusterAlgTool", "AFPSiClusterAlgTool","Tool with algorithm to perform actual clustering"}
	Tool that does the clustering on hits. More...

ToolHandle< IAFPSiRowColToLocalCSTool >	m_rowColToLocalCSToolHandle {this,"rowColToLocalCSTool", "AFPSiRowColToLocalCSTool","Tool to rewrite clusters to xAOD and transform rows and columns to station local coordinates"}
	Tool that creates xAOD and transforms rows and pixels to local coordinate system. More...

ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "", "Monitoring tool"}
	@ brief Monitoring tool More...

ToolHandle< AFP::ISiLocAlignDBTool >	m_siLocAlignDBTool {this, "siLocAlignDBTool", "AFP__SiLocAlignDBTool", "Tool to access DB to get the local alignment constants"}
	@ brief Tool for accessing DB to get the local alignment constants More...

ToolHandle< AFP::ISiGlobAlignDBTool >	m_siGlobAlignDBTool {this, "siGlobAlignDBTool", "AFP__SiGlobAlignDBTool", "Tool to access DB to get the global alignment constants"}
	@ brief Tool for accessing DB to get the global alignment constants More...

Gaudi::Property< std::vector< int > >	m_numberOfLayersInStations {this, "numberOfLayersInStations",{4,4,4,4}, "The size of the array in argument defines number of stations, the value in each entry defines number of layers in the station."}
	Array defining number of stations and layers in each station. More...

Detailed Description

This class reconstructs clusters of pixels.

The clustering algorithm is defined in a tool that is used and can be changed.

Definition at line 53 of file AFPSiClusterTool.h.

Constructor & Destructor Documentation

◆ AFPSiClusterTool()

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

Definition at line 18 of file AFPSiClusterTool.cxx.

   : base_class(type, name, parent)
 {
 }

◆ ~AFPSiClusterTool()

virtual AFPSiClusterTool::~AFPSiClusterTool ( )

inlineoverridevirtual

Definition at line 59 of file AFPSiClusterTool.h.

59 {}

Member Function Documentation

◆ clearAllLayers()

StatusCode AFPSiClusterTool::clearAllLayers ( std::vector< std::vector< AFPSiClusterLayerBasicObj > > & my_layers ) const

private

Runs AFPSiClusterLayerBasicObj::clearHitsAndClusters() on all layers in #my_layers.

Definition at line 109 of file AFPSiClusterTool.cxx.

 {
   for (std::vector<AFPSiClusterLayerBasicObj>& station : my_layers)
     for (AFPSiClusterLayerBasicObj& layer : station)
       layer.clearHitsAndClusters();
   
   return StatusCode::SUCCESS;
 }

◆ clusterEachLayer()

StatusCode AFPSiClusterTool::clusterEachLayer ( std::vector< std::vector< AFPSiClusterLayerBasicObj > > & my_layers ) const

private

Runs tool reconstructing clusters on each layer.

Definition at line 155 of file AFPSiClusterTool.cxx.

 {
   for (std::vector<AFPSiClusterLayerBasicObj>& station : my_layers)
     for (AFPSiClusterLayerBasicObj& layer : station)
       m_clusterAlgToolHandle->doClustering(layer.hits(), layer.clusters()).ignore();
   
   return StatusCode::SUCCESS;
 }

◆ clusterHits()

StatusCode AFPSiClusterTool::clusterHits	(	std::unique_ptr< xAOD::AFPSiHitsClusterContainer > &	clustr,
		const EventContext &	ctx
	)		const

override

Run clusters reconstruction.

This method does full reconstruction from xAOD hits to xAOD clusters. It reads silicon detector hits from StoreGate, runs clustering algorithm, assigns clusters positions in station local coordinate system and saves them in xAOD format to StoreGate.

Definition at line 75 of file AFPSiClusterTool.cxx.

 {
   std::vector< std::vector<AFPSiClusterLayerBasicObj> > my_layers=initLayers(m_numberOfLayersInStations);
  
   if(clearAllLayers(my_layers).isFailure())
   {
     ATH_MSG_WARNING("clearAllLayers failed");
     return StatusCode::FAILURE;
   }
   
   if(fillLayersWithHits(my_layers, ctx).isFailure())
   {
     ATH_MSG_WARNING("fillLayersWithHits failed");
     return StatusCode::FAILURE;
   }
   
   if(clusterEachLayer(my_layers).isFailure())
   {
     ATH_MSG_WARNING("clusterEachLayer failed");
     return StatusCode::FAILURE;
   }
   
   if(saveToXAOD(clustr, my_layers, ctx).isFailure())
   {
     ATH_MSG_WARNING("saveToXAOD failed");
     return StatusCode::FAILURE;
   }
   
   auto clusterSize = Monitored::Scalar("ClusterSize", clustr->size());
   Monitored::Group( m_monTool, clusterSize);
  
   return StatusCode::SUCCESS;
 }

◆ fillLayersWithHits()

StatusCode AFPSiClusterTool::fillLayersWithHits	(	std::vector< std::vector< AFPSiClusterLayerBasicObj > > &	my_layers,
		const EventContext &	ctx
	)		const

private

Reads hits from StoreGate and saves them to appropriate layers in #my_layers.

Definition at line 118 of file AFPSiClusterTool.cxx.

 {
   // retrieve hits
   if (m_AFPSiHitContainerKey.empty()) {
     ATH_MSG_DEBUG("AFPSiClusterTool, no input siHitContainer");
     // this is allowed, there might be no AFP data in the input
     return StatusCode::SUCCESS;
   }
  
   SG::ReadHandle<xAOD::AFPSiHitContainer> siHitContainer( m_AFPSiHitContainerKey, ctx );
   if(!siHitContainer.isValid()) {
      ATH_MSG_WARNING("AFPSiClusterTool failed to retrieve siHitContainer, "<<m_AFPSiHitContainerKey<<", exiting gracefully");
      // unexpected absence of Si hits ?
      return StatusCode::SUCCESS;
   }
   else
   {
     ATH_MSG_DEBUG("AFPSiClusterTool::fillLayersWithHits(), successfully got siHitContainer, there are "<<siHitContainer->size()<<" hits");
     
     auto hitsSize = Monitored::Scalar("HitsSize", siHitContainer->size());
     Monitored::Group( m_monTool, hitsSize);
  
     try {
       // fill layers with hits
       for(const auto *const theHit : *siHitContainer)
         my_layers.at(theHit->stationID()).at(theHit->pixelLayerID()).hits().push_back(theHit);
     }
     catch (const std::out_of_range& outOfRange) {
       ATH_MSG_WARNING("Hit with station or pixel ID outside expected range. Aborting pixels clustering.");
       clearAllLayers(my_layers).ignore();
       return StatusCode::FAILURE;
     }
   }
  
   return StatusCode::SUCCESS;
 }

◆ finalize()

StatusCode AFPSiClusterTool::finalize ( )

overridevirtual

does nothing

Definition at line 70 of file AFPSiClusterTool.cxx.

 {
   return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode AFPSiClusterTool::initialize ( )

overridevirtual

Definition at line 49 of file AFPSiClusterTool.cxx.

 {
   ATH_MSG_DEBUG("Initializing " << name() << "...");
  
   CHECK( m_AFPSiHitContainerKey.initialize( SG::AllowEmpty ) );
  
   // retrieve tools
   CHECK( m_clusterAlgToolHandle.retrieve() );
   CHECK( m_rowColToLocalCSToolHandle.retrieve() );
   CHECK( m_siLocAlignDBTool.retrieve() );
   CHECK( m_siGlobAlignDBTool.retrieve() );
   
   // monitoring
   if (!(m_monTool.name().empty())) {
     CHECK( m_monTool.retrieve() );
     ATH_MSG_DEBUG("m_monTool name: " << m_monTool);
   }
  
   return StatusCode::SUCCESS;
 }

◆ initLayers()

std::vector< std::vector< AFPSiClusterLayerBasicObj > > AFPSiClusterTool::initLayers ( const std::vector< int > & layersInStations ) const

private

Initialise size as well as station and layer ID for #my_layers.

The size of the array in argument defines number of stations, the value in each entry defines number of layers in the station.

Definition at line 25 of file AFPSiClusterTool.cxx.

 {
   // set number of stations
   std::vector< std::vector<AFPSiClusterLayerBasicObj> > my_layers;
   my_layers.resize(layersInStations.size());
  
   // initialise number of layers in each station
   int stationID = 0;
   std::vector<std::vector<AFPSiClusterLayerBasicObj> >::iterator layersIter = my_layers.begin();
   for (const int layersN : layersInStations) {
     int layerID = 0;
     std::vector<AFPSiClusterLayerBasicObj>& layersVec = (*layersIter++);
     layersVec.resize(layersN);
     // set station and layer ID numbers
     for (AFPSiClusterLayerBasicObj& theLayer : layersVec) {
       theLayer.setStationID(stationID);
       theLayer.setLayerID(layerID++);
     }
     stationID++;
   } // close for over layersN
  
   return my_layers;
 }

◆ saveToXAOD()

StatusCode AFPSiClusterTool::saveToXAOD	(	std::unique_ptr< xAOD::AFPSiHitsClusterContainer > &	clustr,
		std::vector< std::vector< AFPSiClusterLayerBasicObj > > &	my_layers,
		const EventContext &	ctx
	)		const

private

Save clusters in xAOD::AFPSiHitsClusterContainer.

Calls m_rowColToLocalCSToolHandle on each reconstructed cluster in each layer. The tool calculates cluster coordinates based on row and column information and creates new xAOD::AFPSiHitsCluster object, which is added to the container.

Definition at line 164 of file AFPSiClusterTool.cxx.

 { 
  
   if (m_AFPSiHitContainerKey.empty()) {
    // this is allowed, there might be no AFP data in the input
     return StatusCode::SUCCESS;
   }
  
   SG::ReadHandle<xAOD::AFPSiHitContainer> siHitContainer( m_AFPSiHitContainerKey, ctx );
   if(!siHitContainer.isValid())
   {
       // this is allowed, there might be no AFP data in the input
       return StatusCode::SUCCESS;
   }
   
   // fill xAOD container
   
   nlohmann::json dataLA, dataGA;
   bool dataLA_init{false}, dataGA_init{false};
   
   for (std::vector<AFPSiClusterLayerBasicObj>& station : my_layers)
     for (AFPSiClusterLayerBasicObj& layer : station) {
       if(layer.clusters().empty()) continue;
       
       const int stationID = layer.stationID();
       const int layerID = layer.layerID();
       
       if(!dataLA_init)
       {
         // read from DB only if necessary
         dataLA=m_siLocAlignDBTool->alignmentData(ctx);
         dataLA_init=true;
       }
       if(!dataGA_init)
       {
         // read from DB only if necessary
         dataGA=m_siGlobAlignDBTool->alignmentData(ctx);
         dataGA_init=true;
       }
       
       const AFP::SiLocAlignData LA=m_siLocAlignDBTool->alignment(dataLA, stationID, layerID);
       const AFP::SiGlobAlignData GA=m_siGlobAlignDBTool->alignment(dataGA, stationID);
       
       for (const AFPSiClusterBasicObj& theCluster : layer.clusters()) {
         // create xAOD object and set cluster coordinates and errors
         xAOD::AFPSiHitsCluster* xAODCluster = m_rowColToLocalCSToolHandle->newXAODLocal(stationID, layerID, LA, GA, theCluster, clusterContainer);
         
         ATH_MSG_DEBUG("have xAODCluster: pixelLayerID "<<xAODCluster->pixelLayerID()<<", xLocal "<<xAODCluster->xLocal()<<", yLocal "<<xAODCluster->yLocal()<<", zLocal "<<xAODCluster->zLocal()<<", nHits "<<xAODCluster->nHits());
         
         // add links to hits
         for (const xAOD::AFPSiHit* theHit : theCluster.hits()) {
           ElementLink< xAOD::AFPSiHitContainer > hitLink;
           hitLink.toContainedElement(*siHitContainer, theHit);
           xAODCluster->addHitLink(hitLink);
         }
       } // end for over layers
     } // end for over stations
  
   return StatusCode::SUCCESS;
 }

Member Data Documentation

◆ m_AFPSiHitContainerKey

SG::ReadHandleKey<xAOD::AFPSiHitContainer> AFPSiClusterTool::m_AFPSiHitContainerKey { this, "AFPSiHitsContainerName", "AFPSiHitContainer", "name of AFPSiHit container" }

private

Definition at line 71 of file AFPSiClusterTool.h.

◆ m_clusterAlgToolHandle

ToolHandle<IAFPSiClusterAlgTool> AFPSiClusterTool::m_clusterAlgToolHandle {this,"clusterAlgTool", "AFPSiClusterAlgTool","Tool with algorithm to perform actual clustering"}

private

Tool that does the clustering on hits.

Definition at line 74 of file AFPSiClusterTool.h.

◆ m_monTool

ToolHandle<GenericMonitoringTool> AFPSiClusterTool::m_monTool {this, "MonTool", "", "Monitoring tool"}

private

@ brief Monitoring tool

Definition at line 80 of file AFPSiClusterTool.h.

◆ m_numberOfLayersInStations

Gaudi::Property<std::vector<int> > AFPSiClusterTool::m_numberOfLayersInStations {this, "numberOfLayersInStations",{4,4,4,4}, "The size of the array in argument defines number of stations, the value in each entry defines number of layers in the station."}

private

Array defining number of stations and layers in each station.

The size of the array in argument defines number of stations, the value in each entry defines number of layers in the station. Default is 4 stations times 4 layers.

Definition at line 93 of file AFPSiClusterTool.h.

◆ m_rowColToLocalCSToolHandle

ToolHandle<IAFPSiRowColToLocalCSTool> AFPSiClusterTool::m_rowColToLocalCSToolHandle {this,"rowColToLocalCSTool", "AFPSiRowColToLocalCSTool","Tool to rewrite clusters to xAOD and transform rows and columns to station local coordinates"}

private

Tool that creates xAOD and transforms rows and pixels to local coordinate system.

Definition at line 77 of file AFPSiClusterTool.h.

◆ m_siGlobAlignDBTool

ToolHandle<AFP::ISiGlobAlignDBTool> AFPSiClusterTool::m_siGlobAlignDBTool {this, "siGlobAlignDBTool", "AFP__SiGlobAlignDBTool", "Tool to access DB to get the global alignment constants"}

private

@ brief Tool for accessing DB to get the global alignment constants

Definition at line 87 of file AFPSiClusterTool.h.

◆ m_siLocAlignDBTool

ToolHandle<AFP::ISiLocAlignDBTool> AFPSiClusterTool::m_siLocAlignDBTool {this, "siLocAlignDBTool", "AFP__SiLocAlignDBTool", "Tool to access DB to get the local alignment constants"}

private

@ brief Tool for accessing DB to get the local alignment constants

Definition at line 84 of file AFPSiClusterTool.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AFPSiClusterTool()

◆ ~AFPSiClusterTool()

Member Function Documentation

◆ clearAllLayers()

◆ clusterEachLayer()

◆ clusterHits()

◆ fillLayersWithHits()

◆ finalize()

◆ initialize()

◆ initLayers()

◆ saveToXAOD()

Member Data Documentation

◆ m_AFPSiHitContainerKey

◆ m_clusterAlgToolHandle

◆ m_monTool

◆ m_numberOfLayersInStations

◆ m_rowColToLocalCSToolHandle

◆ m_siGlobAlignDBTool

◆ m_siLocAlignDBTool