AFP_TDLocRecoTool Class Reference

Algorithm reconstructing tracks from hits. More...

#include <AFP_TDLocRecoTool.h>

Inheritance diagram for AFP_TDLocRecoTool:

Collaboration diagram for AFP_TDLocRecoTool:

Public Member Functions
	AFP_TDLocRecoTool (const std::string &type, const std::string &name, const IInterface *parent)
	~AFP_TDLocRecoTool () 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< IAFPTDLocRecoTrackAlgTool >	m_recoToolsList {this,"RecoToolsList",{},"List of AFP ToF track reconstruction tools"}
	Vector of tool handles to be used for tracks reconstruction.
SG::WriteHandleKeyArray< xAOD::AFPToFTrackContainer >	m_arrayOfWriteHandleKeys {this, "AFPToFTrackContainerList", {"AFPToFTrackContainer"}, "List of output containers"}
	Array of unique write handle keys for track output containers.

Detailed Description

Algorithm reconstructing tracks from hits.

Definition at line 27 of file AFP_TDLocRecoTool.h.

Constructor & Destructor Documentation

AFP_TDLocRecoTool()

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

Definition at line 9 of file AFP_TDLocRecoTool.cxx.

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

~AFP_TDLocRecoTool()

AFP_TDLocRecoTool::~AFP_TDLocRecoTool ( )

inlineoverride

Does nothing.

Definition at line 34 of file AFP_TDLocRecoTool.h.

{}

Member Function Documentation

execute()

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

override

Run pixel clustering tool and next run track reconstruction tools.

Definition at line 104 of file AFP_TDLocRecoTool.cxx.

{
  ATH_MSG_DEBUG("begin AFP_TDLocRecoTool::execute()");
 
  for(const auto &whk : m_arrayOfWriteHandleKeys)
  {
    // reconstruct tracks
    auto afpTrk=std::make_unique<xAOD::AFPToFTrackContainer>();
    auto afpTrkAux=std::make_unique<xAOD::AFPToFTrackAuxContainer>();
    afpTrk->setStore(afpTrkAux.get());
 
    ATH_MSG_DEBUG("Number of AFP ToF tracks = " <<afpTrk->size());
 
    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());
      }
    }
    
    SG::WriteHandle<xAOD::AFPToFTrackContainer> trackContainer(whk, ctx);
    ATH_CHECK( trackContainer.record(std::move(afpTrk), std::move(afpTrkAux)) );
  }
 
  ATH_MSG_DEBUG("end AFP_TDLocRecoTool::execute()");
  return StatusCode::SUCCESS;
}

finalize()

StatusCode AFP_TDLocRecoTool::finalize ( )

override

Does nothing.

Definition at line 135 of file AFP_TDLocRecoTool.cxx.

{
  return StatusCode::SUCCESS;
}

initialize()

StatusCode AFP_TDLocRecoTool::initialize ( )

override

Definition at line 18 of file AFP_TDLocRecoTool.cxx.

{
  ATH_MSG_DEBUG("begin AFP_TDLocRecoTool::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
  
 
  ATH_MSG_DEBUG("end AFP_TDLocRecoTool::initialize()");
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_arrayOfWriteHandleKeys

SG::WriteHandleKeyArray<xAOD::AFPToFTrackContainer> AFP_TDLocRecoTool::m_arrayOfWriteHandleKeys {this, "AFPToFTrackContainerList", {"AFPToFTrackContainer"}, "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 53 of file AFP_TDLocRecoTool.h.

{this, "AFPToFTrackContainerList", {"AFPToFTrackContainer"}, "List of output containers"};

m_recoToolsList

ToolHandleArray<IAFPTDLocRecoTrackAlgTool> AFP_TDLocRecoTool::m_recoToolsList {this,"RecoToolsList",{},"List of AFP ToF 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 48 of file AFP_TDLocRecoTool.h.

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

---

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

• AFP_TDLocRecoTool.h
• AFP_TDLocRecoTool.cxx