AFP_SIDLocRecoTool Class Reference

Algorithm reconstructing tracks from hits clusters. More...

#include <AFP_SIDLocRecoTool.h>

Inheritance diagram for AFP_SIDLocRecoTool:

Collaboration diagram for AFP_SIDLocRecoTool:

Public Member Functions
	AFP_SIDLocRecoTool (const std::string &type, const std::string &name, const IInterface *parent)
	~AFP_SIDLocRecoTool () override
	Does nothing.
StatusCode	initialize () override
StatusCode	execute (const EventContext &ctx) const override
	Run pixel clustering tool and next run track reconstruction tools.
StatusCode	finalize () override
	Does nothing.

Private Attributes
ToolHandleArray< IAFPSiDLocRecoTrackAlgTool >	m_recoToolsList {this,"RecoToolsList",{},"List of AFP track reconstruction tools"}
	Vector of tool handles to be used for tracks reconstruction.
SG::WriteHandleKeyArray< xAOD::AFPTrackContainer >	m_arrayOfWriteHandleKeys {this, "AFPTrackContainerList", {"AFPTrackContainer"}, "List of output containers"}
	Array of unique write handle keys for track output containers.
ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "", "Monitoring tool"}
	@ brief Monitoring tool

Detailed Description

Algorithm reconstructing tracks from hits clusters.

Definition at line 30 of file AFP_SIDLocRecoTool.h.

Constructor & Destructor Documentation

AFP_SIDLocRecoTool()

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

Definition at line 9 of file AFP_SIDLocRecoTool.cxx.

  : base_class(type, name, parent)
{
  ATH_MSG_DEBUG("in AFP_SIDLocRecoTool constructor");
}

~AFP_SIDLocRecoTool()

AFP_SIDLocRecoTool::~AFP_SIDLocRecoTool ( )

inlineoverride

Does nothing.

Definition at line 37 of file AFP_SIDLocRecoTool.h.

{}

Member Function Documentation

execute()

StatusCode AFP_SIDLocRecoTool::execute ( const EventContext & ctx ) const

override

Run pixel clustering tool and next run track reconstruction tools.

Definition at line 110 of file AFP_SIDLocRecoTool.cxx.

{
  ATH_MSG_DEBUG("in AFP_SIDLocRecoTool::execute()");
 
 
  auto trkSize = Monitored::Scalar("TrkSize", 0.0);
 
  for(const auto &whk : m_arrayOfWriteHandleKeys)
  {
    // reconstruct tracks
    auto afpTrk=std::make_unique<xAOD::AFPTrackContainer>();
    auto afpTrkAux=std::make_unique<xAOD::AFPTrackAuxContainer>();
    afpTrk->setStore(afpTrkAux.get());
 
    for(const auto &recoTool : m_recoToolsList)
    {
      if(recoTool->outputContainerName() != whk.key()) continue;
 
      if( recoTool->reconstructTracks(afpTrk, ctx).isFailure() )
      {
        ATH_MSG_WARNING ("Failed to reconstruct tracks with algorithm = "<<recoTool->name());
      }
    }
        
    trkSize += afpTrk->size();
    ATH_MSG_DEBUG("Number of AFP SID tracks = " << trkSize);
 
    SG::WriteHandle<xAOD::AFPTrackContainer> trackContainer(whk, ctx);
    ATH_CHECK( trackContainer.record(std::move(afpTrk), std::move(afpTrkAux)) );
  }
  
  Monitored::Group( m_monTool, trkSize);
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode AFP_SIDLocRecoTool::finalize ( )

override

Does nothing.

Definition at line 146 of file AFP_SIDLocRecoTool.cxx.

{
  return StatusCode::SUCCESS;
}

initialize()

StatusCode AFP_SIDLocRecoTool::initialize ( )

override

Definition at line 18 of file AFP_SIDLocRecoTool.cxx.

{
  ATH_MSG_DEBUG("in AFP_SIDLocRecoTool::initialize()");
 
  // track reconstruction tools
  if(m_recoToolsList.empty())
  {
    ATH_MSG_ERROR("No track reconstruction tools set, check settings in AFP_LocReco/AFP_LocReco.py. Aborting.");
    return StatusCode::FAILURE;
  }
  else
  {
    CHECK( m_recoToolsList.retrieve() );
  }
 
  // output containers for the track reconstruction tools
  if(m_arrayOfWriteHandleKeys.empty())
  {
    ATH_MSG_ERROR("No output track containers provided, check settings in AFP_LocReco/AFP_LocReco.py. Aborting.");
    return StatusCode::FAILURE;
  }
  else
  {
    CHECK( m_arrayOfWriteHandleKeys.initialize() );
  }
 
 
  // the code in execute relies on the facts that (a) the keys in WriteHandleKeyArray are unique; (b) all output container names from track reco tools are also in WriteHandleKeyArray; and moreover (c) that there are no extra WriteHandleKeys that are not present in any track reco tools
  // case (c) wouldn't necessarily break things but it's not a sign of a good configuration and thus it's forbidden as well
  // first, get names from write handle keys
  std::vector<std::string> listOfWHKeys;
  for(const auto &whk : m_arrayOfWriteHandleKeys)
  {
    ATH_MSG_DEBUG("have WHKey "<<whk.key());
    listOfWHKeys.push_back(whk.key());
  }
  unsigned int all_WHkeys=listOfWHKeys.size();
  // remove duplicities, there shouldn't be any
  std::sort(listOfWHKeys.begin(), listOfWHKeys.end());
  listOfWHKeys.erase(std::unique(listOfWHKeys.begin(),listOfWHKeys.end()), listOfWHKeys.end());
  if(listOfWHKeys.size() != all_WHkeys)
  {
    ATH_MSG_ERROR("It seems write handle keys do not have unique values, check settings in AFP_LocReco/AFP_LocReco.py. Aborting.");
    return StatusCode::FAILURE;
  }
  // get names from track reco tools
  std::vector<std::string> listOfOutputContainers;
  for(const auto &recoTool : m_recoToolsList)
  {
    ATH_MSG_DEBUG("have ouput container "<<recoTool->outputContainerName());
    listOfOutputContainers.push_back(recoTool->outputContainerName());
  }
  // remove duplicities, they are allowed
  std::sort(listOfOutputContainers.begin(), listOfOutputContainers.end());
  listOfOutputContainers.erase(std::unique(listOfOutputContainers.begin(),listOfOutputContainers.end()), listOfOutputContainers.end());
  // write handle keys and names from track reco tools should have the same size
  if(listOfWHKeys.size() != listOfOutputContainers.size())
  {
    ATH_MSG_ERROR("There is different number of unique write handle keys ("<<listOfWHKeys.size()<<") and unique output containers ("<<listOfOutputContainers.size()<<"). Aborting");
    return StatusCode::FAILURE;
  }
  // check they are the same; one of these loops are not strictly neccessary, but they will print outstanding names
  bool doAbort=false;
  for(const auto &trkOutCont : listOfOutputContainers)
  {
    if(std::find(listOfWHKeys.begin(),listOfWHKeys.end(),trkOutCont) == listOfWHKeys.end())
    {
      ATH_MSG_ERROR("Cannot find track reconstruction output container "<<trkOutCont<<" in write handle keys. Aborting");
      doAbort=true;
    }
  }
  for(const auto &whk : listOfWHKeys)
  {
    if(std::find(listOfOutputContainers.begin(),listOfOutputContainers.end(),whk) == listOfOutputContainers.end())
    {
      ATH_MSG_ERROR("Cannot find write handle key "<<whk<<" in track reconstruction output containers. Aborting");
      doAbort=true;
    }
  }
  if(doAbort) return StatusCode::FAILURE;
  // Now, we are sure it's setup correctly
 
 
  // monitoring
  if (!(m_monTool.name().empty())) {
    CHECK( m_monTool.retrieve() );
    ATH_MSG_DEBUG("m_monTool name: " << m_monTool);
  }
  
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_arrayOfWriteHandleKeys

SG::WriteHandleKeyArray<xAOD::AFPTrackContainer> AFP_SIDLocRecoTool::m_arrayOfWriteHandleKeys {this, "AFPTrackContainerList", {"AFPTrackContainer"}, "List of output containers"}

private

Array of unique write handle keys for track output containers.

Each write handle key has to be unique and in sync with m_recoToolsList. It's possible for several track reco algorithms contributing to the common container. Ideally, one should setup track reco containers (in AFP_LocReco/AFP_LocReco.py) and let the python script pick unique names.

Definition at line 57 of file AFP_SIDLocRecoTool.h.

{this, "AFPTrackContainerList", {"AFPTrackContainer"}, "List of output containers"};

m_monTool

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

private

@ brief Monitoring tool

Definition at line 60 of file AFP_SIDLocRecoTool.h.

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

m_recoToolsList

ToolHandleArray<IAFPSiDLocRecoTrackAlgTool> AFP_SIDLocRecoTool::m_recoToolsList {this,"RecoToolsList",{},"List of AFP track reconstruction tools"}

private

Vector of tool handles to be used for tracks reconstruction.

Each station has its own track reco algorithm. This array contains all of them

Definition at line 52 of file AFP_SIDLocRecoTool.h.

{this,"RecoToolsList",{},"List of AFP track reconstruction tools"};

---

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

• AFP_SIDLocRecoTool.h
• AFP_SIDLocRecoTool.cxx