AFP_GlobRecoTool Class Reference

Algorithm reconstructing protons from tracks. More...

#include <AFP_GlobRecoTool.h>

Inheritance diagram for AFP_GlobRecoTool:

Collaboration diagram for AFP_GlobRecoTool:

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

Private Attributes
ToolHandleArray< IAFP_ProtonRecoTool >	m_recoToolsList {this,"RecoToolsList",{},"List of AFP proton reconstruction tools"}
	Vector of tool handles to be used for proton reconstruction.
SG::WriteHandleKeyArray< xAOD::AFPProtonContainer >	m_arrayOfWriteHandleKeys {this, "AFPProtonContainerList", {"AFPProtonContainer"}, "List of output containers"}
	Array of unique write handle keys for track output containers.

Detailed Description

Algorithm reconstructing protons from tracks.

Definition at line 30 of file AFP_GlobRecoTool.h.

Constructor & Destructor Documentation

AFP_GlobRecoTool()

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

Definition at line 9 of file AFP_GlobRecoTool.cxx.

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

~AFP_GlobRecoTool()

AFP_GlobRecoTool::~AFP_GlobRecoTool ( )

default

Does nothing.

Member Function Documentation

execute()

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

override

Run proton reco tool.

Definition at line 113 of file AFP_GlobRecoTool.cxx.

{
  ATH_MSG_DEBUG("in AFP_GlobRecoTool::execute()");
 
 
  for(const auto &whk : m_arrayOfWriteHandleKeys)
  {
    // reconstruct protons
    auto afpProton=std::make_unique<xAOD::AFPProtonContainer>();
    auto afpProtonAux=std::make_unique<xAOD::AFPProtonAuxContainer>();
    afpProton->setStore(afpProtonAux.get());
 
    for(const auto &recoTool : m_recoToolsList)
    {
      if(recoTool->outputContainerName() != whk.key()) continue;
 
      if( recoTool->doProtonReco(afpProton, ctx).isFailure() )
      {
        ATH_MSG_WARNING ("Failed to reconstruct protons with algorithm = "<<recoTool->name());
      }
    }
    
    ATH_MSG_DEBUG("write handle key "<<whk<<", have "<<afpProton->size()<<" reconstructed protons");
        
 
    SG::WriteHandle<xAOD::AFPProtonContainer> protonContainer(whk, ctx);
    ATH_CHECK( protonContainer.record(std::move(afpProton), std::move(afpProtonAux)) );
  }
  
  return StatusCode::SUCCESS;
}

initialize()

StatusCode AFP_GlobRecoTool::initialize ( )

override

Definition at line 18 of file AFP_GlobRecoTool.cxx.

{
  ATH_MSG_DEBUG("in AFP_GlobRecoTool::initialize()");
 
  // proton reconstruction tools
  if(m_recoToolsList.empty())
  {
    ATH_MSG_ERROR("No proton reconstruction tools set, check settings in AFP_GlobReco/AFP_GlobReco.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 proton reconstruction tools
  if(m_arrayOfWriteHandleKeys.empty())
  {
    ATH_MSG_ERROR("No output proton containers provided, check settings in AFP_GlobReco/AFP_GlobReco.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 proton reco tools are also in WriteHandleKeyArray; and moreover (c) that there are no extra WriteHandleKeys that are not present in any proton 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_GlobReco/AFP_GlobReco.py. Aborting.");
    return StatusCode::FAILURE;
  }
  // get names from proton 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 proton 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 proton 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 proton 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::AFPProtonContainer> AFP_GlobRecoTool::m_arrayOfWriteHandleKeys {this, "AFPProtonContainerList", {"AFPProtonContainer"}, "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_GlobReco/AFP_GlobReco.py) and let the python script pick unique names.

Definition at line 53 of file AFP_GlobRecoTool.h.

{this, "AFPProtonContainerList", {"AFPProtonContainer"}, "List of output containers"};

m_recoToolsList

ToolHandleArray<IAFP_ProtonRecoTool> AFP_GlobRecoTool::m_recoToolsList {this,"RecoToolsList",{},"List of AFP proton reconstruction tools"}

private

Vector of tool handles to be used for proton reconstruction.

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

Definition at line 48 of file AFP_GlobRecoTool.h.

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

---

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

• AFP_GlobRecoTool.h
• AFP_GlobRecoTool.cxx