AFPSiClusterTool Class Reference

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
StatusCode	clusterHits (std::unique_ptr< xAOD::AFPSiHitsClusterContainer > &clustr, const EventContext &ctx) const override
	Run clusters reconstruction.

Private Member Functions
StatusCode	clearAllLayers (std::vector< std::vector< AFPSiClusterLayerBasicObj > > &my_layers) const
	Runs AFPSiClusterLayerBasicObj::clearHitsAndClusters() on all layers in #my_layers.
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.
StatusCode	clusterEachLayer (std::vector< std::vector< AFPSiClusterLayerBasicObj > > &my_layers) const
	Runs tool reconstructing clusters on each layer.
StatusCode	saveToXAOD (std::unique_ptr< xAOD::AFPSiHitsClusterContainer > &clustr, std::vector< std::vector< AFPSiClusterLayerBasicObj > > &my_layers, const EventContext &ctx) const
	Save clusters in xAOD::AFPSiHitsClusterContainer.
std::vector< std::vector< AFPSiClusterLayerBasicObj > >	initLayers (const std::vector< int > &layersInStations) const
	Initialise size as well as station and layer ID for #my_layers.

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.
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.
ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "", "Monitoring tool"}
	@ brief Monitoring tool
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
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
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.

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.

{}

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.

{ this, "AFPSiHitsContainerName", "AFPSiHitContainer", "name of AFPSiHit container" };

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.

{this,"clusterAlgTool", "AFPSiClusterAlgTool","Tool with algorithm to perform actual clustering"};

m_monTool

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

private

@ brief Monitoring tool

Definition at line 80 of file AFPSiClusterTool.h.

{this, "MonTool", "", "Monitoring tool"};

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.

{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."};

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.

{this,"rowColToLocalCSTool", "AFPSiRowColToLocalCSTool","Tool to rewrite clusters to xAOD and transform rows and columns to station local coordinates"}; 

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.

{this, "siGlobAlignDBTool", "AFP__SiGlobAlignDBTool", "Tool to access DB to get the global alignment constants"};

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.

{this, "siLocAlignDBTool", "AFP__SiLocAlignDBTool", "Tool to access DB to get the local alignment constants"};

---

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

• AFPSiClusterTool.h
• AFPSiClusterTool.cxx