TrigAFPToFHypoAlg Class Reference

#include <TrigAFPToFHypoAlg.h>

Inheritance diagram for TrigAFPToFHypoAlg:

Collaboration diagram for TrigAFPToFHypoAlg:

Public Member Functions
	TrigAFPToFHypoAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &context) const override

Private Attributes
SG::ReadHandleKey< xAOD::VertexContainer >	m_inputIdVtxKey {this, "VertexContainer", "HLT_IDVertex_FS", "ID vertex collection"}
SG::ReadHandleKey< xAOD::AFPVertexContainer >	m_inputAfpVtxKey {this, "AFPVertexContainer", "HLT_AFPVertex", "AFP ToF vertex collection"}
ToolHandleArray< TrigAFPToFHypoTool >	m_hypoTools {this, "HypoTools", {}}
ToolHandle< GenericMonitoringTool >	m_monTool { this, "MonTool", "", "Monitor tool for TrigAFPToFHypo" }

Detailed Description

Definition at line 24 of file TrigAFPToFHypoAlg.h.

Constructor & Destructor Documentation

TrigAFPToFHypoAlg()

TrigAFPToFHypoAlg::TrigAFPToFHypoAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 9 of file TrigAFPToFHypoAlg.cxx.

                                                                                   : 
  ::HypoBase(name, pSvcLocator)
{
}

Member Function Documentation

execute()

StatusCode TrigAFPToFHypoAlg::execute ( const EventContext & context ) const

overridevirtual

Definition at line 24 of file TrigAFPToFHypoAlg.cxx.

{
  ATH_MSG_DEBUG("TrigAFPToFHypoAlg::execute()");
 
  // Create the input and output decision containers
  SG::ReadHandle<DecisionContainer> inputDecisionsHandle(decisionInput(), context);
  SG::WriteHandle<DecisionContainer> outputDecisionsHandle = createAndStore(decisionOutput(), context ); 
 
  // Jet vertex container
  SG::ReadHandle<xAOD::VertexContainer> idVtxHandle(m_inputIdVtxKey, context);
  ATH_CHECK(idVtxHandle.isValid());
 
  // AFP ToF vertex container
  SG::ReadHandle<xAOD::AFPVertexContainer> afpVtxHandle(m_inputAfpVtxKey, context);
  ATH_CHECK(afpVtxHandle.isValid());
 
  // monitor reason for skipping hypo tool
  auto skipHypoTool = Monitored::Scalar<int>("skipHypoTool", 0);
 
  // vertex handle error checking
  if (!afpVtxHandle.isValid()) {
    ATH_MSG_DEBUG("AFP vertex handle invalid");
    skipHypoTool = 1;
  }
  if (!idVtxHandle.isValid()) {
    ATH_MSG_DEBUG("ID vertex handle invalid");
    skipHypoTool = 2;
  }
 
  // check vertex handle size 
  if (afpVtxHandle->size() == 0) {
    ATH_MSG_DEBUG("No AFP vertices");
    skipHypoTool = 3;
  }
  if (idVtxHandle->size() == 0) {
    ATH_MSG_DEBUG("No ID vertices");
    skipHypoTool = 4;
  }
 
  // check if the only vertex has tracks (exclude 0 AFP vertices)
  if (skipHypoTool != 3 && idVtxHandle->size() == 1 && idVtxHandle->at(0)->vxTrackAtVertexAvailable() == false) {
    ATH_MSG_DEBUG("The only ID vertex has no tracks"); 
    skipHypoTool = 5;
  }
 
  // monitor number of vertices
  auto n_afp_vertex = Monitored::Scalar<size_t>("afp_vtx_count", 0);
  auto n_id_vertex = Monitored::Scalar<size_t>("id_vtx_count", 0);
 
  // loop over AFP vertices 
  for (size_t i = 0; i < afpVtxHandle->size(); ++i) {
    const xAOD::AFPVertex* afpVtx = afpVtxHandle->at(i);
    // if hypo tool is not skipped, print vertex information
    if (skipHypoTool == 0) ATH_MSG_DEBUG("AFP vertex [" << i << "] z position: " << afpVtx->position());
    auto afp_vtx_z = Monitored::Scalar<float>("afp_vtx_z", afpVtx->position());
    Monitored::fill(m_monTool, afp_vtx_z);
    n_afp_vertex += 1;
  }
  Monitored::fill(m_monTool, n_afp_vertex);
 
  // loop over ID vertices
  for (size_t i = 0; i < idVtxHandle->size(); ++i) {
    const xAOD::Vertex* idVtx = idVtxHandle->at(i);
    // if hypo tool is not skipped, print vertex information
    if (skipHypoTool == 0) ATH_MSG_DEBUG("ID vertex [" << i << "] z position: " << idVtx->z()
                                        << " chi2: " << idVtx->chiSquared()
                                        << " ndof: " << idVtx->numberDoF());
    // skip dummy vertex
    if (idVtx->vxTrackAtVertexAvailable() == false) continue;
    if (idVtx->nTrackParticles() == 0) continue; 
    
    auto id_vtx_z = Monitored::Scalar<float>("id_vtx_z", idVtx->z());
    Monitored::fill(m_monTool, id_vtx_z);
    n_id_vertex += 1;
  }
  Monitored::fill(m_monTool,n_id_vertex);
 
  // Vector of structs to pass to hypo tool
  std::vector<TrigAFPToFHypoTool::AFPToFHypoToolInfo> hypoToolInput;
 
  // monitor the reason for skipping the hypo tool
  Monitored::fill(m_monTool, skipHypoTool);
 
  if (skipHypoTool != 0)
  {
    ATH_MSG_DEBUG("Skipping hypo tool");
  }
  else
  {
    for (size_t i = 0; i < inputDecisionsHandle->size(); ++i) {
      const Decision* previousDecision = inputDecisionsHandle->at(i);
 
      const xAOD::AFPVertex* afpVtx = afpVtxHandle->at(0);
      const xAOD::Vertex* idVtx = idVtxHandle->at(0);
 
      // monitor delta z between vertices
      auto delta_z = Monitored::Scalar<float>("delta_z", afpVtx->position() - idVtx->z());
      Monitored::fill(m_monTool, delta_z);
 
      // Create an output Decision Object to track this object in the trigger navigation.
      Decision* outputDecision = newDecisionIn(outputDecisionsHandle.ptr(), hypoAlgNodeName());
 
      // We link this 'outputDecision' to its parent, 'inputDecision'
      linkToPrevious(outputDecision, previousDecision, context);
 
      // We attach the "feature" ElementLink which associates the DecisionObject with the AFP vertex
      outputDecision->setObjectLink(featureString(), ElementLink<xAOD::AFPVertexContainer>(*afpVtxHandle, i, context));
 
      // We collect the set of chains which were active on this inputDecision coming in to this Step.
      DecisionIDContainer inputPassingChains;
      decisionIDs(previousDecision, inputPassingChains);
 
      hypoToolInput.emplace_back(inputPassingChains, afpVtx, idVtx, outputDecision);
    }
  }
 
  // Each individual chain has its own HypoTool, we loop over them and give them the hypoToolInput to discriminate over
  for (const auto &tool : m_hypoTools) {
    ATH_CHECK(tool->decide(hypoToolInput));
  }
 
  // Performs some runtime-checks.
  ATH_CHECK( hypoBaseOutputProcessing(outputDecisionsHandle) );
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TrigAFPToFHypoAlg::initialize ( )

overridevirtual

Definition at line 14 of file TrigAFPToFHypoAlg.cxx.

{
  ATH_MSG_DEBUG("TrigAFPToFHypoAlg::initialize()");
  ATH_CHECK(m_inputIdVtxKey.initialize()); //ID vertex
  ATH_CHECK(m_inputAfpVtxKey.initialize()); //ToF vertex
  ATH_CHECK(m_hypoTools.retrieve());
  if (!m_monTool.empty()) ATH_CHECK(m_monTool.retrieve());
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_hypoTools

ToolHandleArray<TrigAFPToFHypoTool> TrigAFPToFHypoAlg::m_hypoTools {this, "HypoTools", {}}

private

Definition at line 35 of file TrigAFPToFHypoAlg.h.

{this, "HypoTools", {}};

m_inputAfpVtxKey

SG::ReadHandleKey<xAOD::AFPVertexContainer> TrigAFPToFHypoAlg::m_inputAfpVtxKey {this, "AFPVertexContainer", "HLT_AFPVertex", "AFP ToF vertex collection"}

private

Definition at line 34 of file TrigAFPToFHypoAlg.h.

{this, "AFPVertexContainer", "HLT_AFPVertex", "AFP ToF vertex collection"};

m_inputIdVtxKey

SG::ReadHandleKey< xAOD::VertexContainer > TrigAFPToFHypoAlg::m_inputIdVtxKey {this, "VertexContainer", "HLT_IDVertex_FS", "ID vertex collection"}

private

Definition at line 33 of file TrigAFPToFHypoAlg.h.

{this, "VertexContainer", "HLT_IDVertex_FS", "ID vertex collection"};

m_monTool

ToolHandle<GenericMonitoringTool> TrigAFPToFHypoAlg::m_monTool { this, "MonTool", "", "Monitor tool for TrigAFPToFHypo" }

private

Definition at line 38 of file TrigAFPToFHypoAlg.h.

{ this, "MonTool", "", "Monitor tool for TrigAFPToFHypo" };

---

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

• TrigAFPToFHypoAlg.h
• TrigAFPToFHypoAlg.cxx