AFP_VertexRecoTool Class Reference

Algorithm reconstructing vertices from protons. More...

#include <AFP_VertexRecoTool.h>

Inheritance diagram for AFP_VertexRecoTool:

Collaboration diagram for AFP_VertexRecoTool:

Public Member Functions
	AFP_VertexRecoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~AFP_VertexRecoTool ()=default
	Does nothing.
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
	Run vertex reco tool.

Private Attributes
ToolHandleArray< IAFP_TimeRecoTool >	m_recoToolsList {this,"RecoToolsList",{},"List of AFP vertex reconstruction tools"}
	Vector of tool handles to be used for vertex reconstruction.
SG::WriteHandleKeyArray< xAOD::AFPVertexContainer >	m_arrayOfWriteHandleKeys {this, "AFPVertexContainerList", {"AFPVertexContainer"}, "List of output containers"}
	Array of unique write handle keys for vertex output container.

Detailed Description

Algorithm reconstructing vertices from protons.

Definition at line 30 of file AFP_VertexRecoTool.h.

Constructor & Destructor Documentation

AFP_VertexRecoTool()

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

Definition at line 9 of file AFP_VertexRecoTool.cxx.

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

~AFP_VertexRecoTool()

virtual AFP_VertexRecoTool::~AFP_VertexRecoTool ( )

virtualdefault

Does nothing.

Member Function Documentation

execute()

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

overridevirtual

Run vertex reco tool.

Definition at line 113 of file AFP_VertexRecoTool.cxx.

{
  ATH_MSG_DEBUG("in AFP_VertexRecoTool::execute()");
 
 
  for(const auto &whk : m_arrayOfWriteHandleKeys)
  {
    // reconstruct vertices
    auto afpVertex=std::make_unique<xAOD::AFPVertexContainer>();
    auto afpVertexAux=std::make_unique<xAOD::AFPVertexAuxContainer>();
    afpVertex->setStore(afpVertexAux.get());
 
    for(const auto &recoTool : m_recoToolsList)
    {
      if(recoTool->outputContainerName() != whk.key()) continue;
 
      if( recoTool->doVertexReco(afpVertex, ctx).isFailure() )
      {
        ATH_MSG_WARNING ("Failed to reconstruct vertices with algorithm = "<<recoTool->name());
      }
    }
    
    ATH_MSG_DEBUG("write handle key "<<whk<<", have "<<afpVertex->size()<<" reconstructed vertices");
        
 
    SG::WriteHandle<xAOD::AFPVertexContainer> vertexContainer(whk, ctx);
    ATH_CHECK( vertexContainer.record(std::move(afpVertex), std::move(afpVertexAux)) );
  }
  
  return StatusCode::SUCCESS;
}

initialize()

StatusCode AFP_VertexRecoTool::initialize ( )

overridevirtual

Definition at line 18 of file AFP_VertexRecoTool.cxx.

{
  ATH_MSG_DEBUG("in AFP_VertexRecoTool::initialize()");
 
  // vertex reconstruction tools
  if(m_recoToolsList.empty())
  {
    ATH_MSG_ERROR("No vertex reconstruction tools set, check settings in AFP_VertexReco/AFP_VertexReco.py. Aborting.");
    return StatusCode::FAILURE;
  }
  else
  {
    ATH_MSG_DEBUG("There are these tools in m_recoToolsList: "<<m_recoToolsList<<", will retrieve");
    CHECK( m_recoToolsList.retrieve() );
  }
 
  // output containers for the vertex reconstruction tools
  if(m_arrayOfWriteHandleKeys.empty())
  {
    ATH_MSG_ERROR("No output vertex containers provided, check settings in AFP_VertexReco/AFP_VertexReco.py. Aborting.");
    return StatusCode::FAILURE;
  }
  else
  {
    ATH_MSG_DEBUG("There are these write handle keys in m_arrayOfWriteHandleKeys: "<<m_arrayOfWriteHandleKeys<<", will initialize");
    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 vertex reco tools are also in WriteHandleKeyArray; and moreover (c) that there are no extra WriteHandleKeys that are not present in any vertex 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_VertexReco/AFP_VertexReco.py. Aborting.");
    return StatusCode::FAILURE;
  }
  // get names from vertex 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 vertex 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 vertex 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 vertex reconstruction output containers. Aborting");
      doAbort=true;
    }
  }
  if(doAbort) return StatusCode::FAILURE;
  // Now, we are sure it's setup correctly
 
 
// monitoring tool to be added soon
  // 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::AFPVertexContainer> AFP_VertexRecoTool::m_arrayOfWriteHandleKeys {this, "AFPVertexContainerList", {"AFPVertexContainer"}, "List of output containers"}

private

Array of unique write handle keys for vertex output container.

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

Definition at line 53 of file AFP_VertexRecoTool.h.

{this, "AFPVertexContainerList", {"AFPVertexContainer"}, "List of output containers"};

m_recoToolsList

ToolHandleArray<IAFP_TimeRecoTool> AFP_VertexRecoTool::m_recoToolsList {this,"RecoToolsList",{},"List of AFP vertex reconstruction tools"}

private

Vector of tool handles to be used for vertex reconstruction.

Several time reco algorithms will be implemented. This array contains all of them

Definition at line 48 of file AFP_VertexRecoTool.h.

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

---

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

• AFP_VertexRecoTool.h
• AFP_VertexRecoTool.cxx