DerivationFramework::DeltaRTool Class Reference

#include <DeltaRTool.h>

Inheritance diagram for DerivationFramework::DeltaRTool:

Collaboration diagram for DerivationFramework::DeltaRTool:

Public Member Functions
virtual StatusCode	initialize () override final
virtual StatusCode	finalize () override final
virtual StatusCode	addBranches (const EventContext &ctx) const override final

Private Member Functions
StatusCode	getDeltaRs (std::vector< float > *, const EventContext &ctx) const

Static Private Member Functions
static float	calculateDeltaR (float, float, float, float)

Private Attributes
Gaudi::Property< std::string >	m_expression {this, "ObjectRequirements", ""}
Gaudi::Property< std::string >	m_2ndExpression {this, "SecondObjectRequirements", ""}
SG::WriteHandleKey< std::vector< float > >	m_sgName {this,"StoreGateEntryName","","SG key of output object"}
SG::ReadHandleKey< xAOD::IParticleContainer >	m_containerName {this,"ContainerName","","SG key of first container"}
SG::ReadHandleKey< xAOD::IParticleContainer >	m_containerName2 {this,"SecondContainerName","","SG key of first container"}

Detailed Description

Definition at line 24 of file DeltaRTool.h.

Member Function Documentation

addBranches()

StatusCode DerivationFramework::DeltaRTool::addBranches ( const EventContext &  ctx ) const

finaloverridevirtual

Definition at line 36 of file DeltaRTool.cxx.

  {
    // Write deltaRs to SG for access by downstream algs
    if (evtStore()->contains<std::vector<float> >(m_sgName.key())) { // FIXME Use Handles
      ATH_MSG_ERROR("Tool is attempting to write a StoreGate key " << m_sgName << " which already exists. Please use a different key");
      return StatusCode::FAILURE;
    }
    std::unique_ptr<std::vector<float> > deltaRs(new std::vector<float>());
    ATH_CHECK(getDeltaRs(deltaRs.get(), ctx ));
 
    SG::WriteHandle<std::vector<float> > writeHandle(m_sgName, ctx);
    ATH_CHECK(writeHandle.record(std::move(deltaRs)));
 
    return StatusCode::SUCCESS;
  }

calculateDeltaR()

float DerivationFramework::DeltaRTool::calculateDeltaR ( float  phi1, float  phi2, float  eta1, float  eta2  )

staticprivate

Definition at line 138 of file DeltaRTool.cxx.

  {
    float deltaPhi = fabs(phi1-phi2);
    if (deltaPhi>TMath::Pi()) deltaPhi = 2.0*TMath::Pi() - deltaPhi;
    float deltaPhiSq = deltaPhi*deltaPhi;
    float deltaEtaSq = (eta1-eta2)*(eta1-eta2);
    float deltaR = sqrt(deltaPhiSq+deltaEtaSq);
    return deltaR;
  }

finalize()

StatusCode DerivationFramework::DeltaRTool::finalize ( )

finaloverridevirtual

Definition at line 30 of file DeltaRTool.cxx.

  {
    ATH_CHECK(finalizeParser());
    return StatusCode::SUCCESS;
  }

getDeltaRs()

StatusCode DerivationFramework::DeltaRTool::getDeltaRs ( std::vector< float > *  deltaRs, const EventContext &  ctx  ) const

private

Definition at line 52 of file DeltaRTool.cxx.

  {
 
    // check the relevant information is available
    if (m_containerName.key().empty()) {
      ATH_MSG_WARNING("Input container missing - returning zero");
      deltaRs->push_back(0.0);
      return StatusCode::FAILURE;
    }
    bool secondContainer(false);
    if (!m_containerName2.key().empty()) secondContainer=true;
 
    // get the relevant branches
    SG::ReadHandle<xAOD::IParticleContainer> particles{m_containerName, ctx};
 
    const xAOD::IParticleContainer* secondParticles(nullptr);
    if (secondContainer) {
      SG::ReadHandle<xAOD::IParticleContainer> particleHdl2{m_containerName2, ctx};
      secondParticles=particleHdl2.cptr();
    }
 
    // get the positions of the elements which pass the requirement
    std::vector<int> entries, entries2;
    if (!m_expression.empty()) {entries = m_parser[kDeltaRToolParser1]->evaluateAsVector();}
    else {entries.assign(particles->size(),1);} // default: include all elements
    unsigned int nEntries = entries.size();
    // check the sizes are compatible
    if (particles->size() != nEntries ) {
      ATH_MSG_FATAL("Branch sizes incompatible");
      return StatusCode::FAILURE;
    }
    unsigned int nEntries2(0);
    if (secondContainer) {
      if (!m_2ndExpression.empty()) {entries2 =  m_parser[kDeltaRToolParser2]->evaluateAsVector();}
      else {entries2.assign(secondParticles->size(),1);} // default: include all elements
      nEntries2 = entries2.size();
      // check the sizes are compatible
      if (secondParticles->size() != nEntries2 ) {
        ATH_MSG_FATAL("Branch sizes incompatible - returning zero");
        return StatusCode::FAILURE;
      }
    }
 
    // Double loop to get the pairs for which the mass should be calculated
    std::vector<std::pair<unsigned, unsigned>> pairs;
    if (!secondContainer) {
      for (unsigned outerIt=0; outerIt<nEntries; ++outerIt) {
        for (unsigned innerIt=outerIt+1; innerIt<nEntries; ++innerIt) {
          if (entries[outerIt]==1 && entries[innerIt]==1) {
            pairs.emplace_back(outerIt, innerIt);
          }
        }
      }
    }
 
    if (secondContainer) {
      for (unsigned coll1It=0; coll1It<nEntries; ++coll1It) {
        for (unsigned coll2It=0; coll2It<nEntries2; ++coll2It) {
          //coverity[copy_paste_error]
          if (entries[coll1It]==1 && entries2[coll2It]==1) {
            pairs.emplace_back(coll1It, coll2It);
          }
        }
      }
    }
 
    // Loop over the pairs; calculate the mass; put into vector and return
    for (const auto & [first, second] : pairs) {
      if (!secondContainer) {
        float phi1f = ((*particles)[first])->p4().Phi(); float phi2f = ((*particles)[second])->p4().Phi();
        float eta1f = ((*particles)[first])->p4().Eta(); float eta2f = ((*particles)[second])->p4().Eta();
        float deltaR = calculateDeltaR(phi1f,phi2f,eta1f,eta2f);
        deltaRs->push_back(deltaR);
      }
      if (secondContainer) {
        float phi1f = ((*particles)[first])->p4().Phi(); float phi2f = ((*secondParticles)[second])->p4().Phi();
        float eta1f = ((*particles)[first])->p4().Eta(); float eta2f = ((*secondParticles)[second])->p4().Eta();
        float deltaR = calculateDeltaR(phi1f,phi2f,eta1f,eta2f);
        deltaRs->push_back(deltaR);
      }
    }
 
    return StatusCode::SUCCESS;
 
  }

initialize()

StatusCode DerivationFramework::DeltaRTool::initialize ( )

finaloverridevirtual

Definition at line 13 of file DeltaRTool.cxx.

  {
    if (m_sgName.key().empty()) {
      ATH_MSG_ERROR("No SG name provided for the output of invariant mass tool!");
      return StatusCode::FAILURE;
    }
    ATH_CHECK(m_sgName.initialize());
    ATH_CHECK(m_containerName.initialize());
 
    if (!m_containerName2.key().empty()) {
      ATH_CHECK(m_containerName2.initialize());
    }
 
    ATH_CHECK(initializeParser( {m_expression, m_2ndExpression} ));
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_2ndExpression

Gaudi::Property<std::string> DerivationFramework::DeltaRTool::m_2ndExpression {this, "SecondObjectRequirements", ""}

private

Definition at line 35 of file DeltaRTool.h.

m_containerName

SG::ReadHandleKey<xAOD::IParticleContainer> DerivationFramework::DeltaRTool::m_containerName {this,"ContainerName","","SG key of first container"}

private

Definition at line 37 of file DeltaRTool.h.

m_containerName2

SG::ReadHandleKey<xAOD::IParticleContainer> DerivationFramework::DeltaRTool::m_containerName2 {this,"SecondContainerName","","SG key of first container"}

private

Definition at line 38 of file DeltaRTool.h.

m_expression

Gaudi::Property<std::string> DerivationFramework::DeltaRTool::m_expression {this, "ObjectRequirements", ""}

private

Definition at line 34 of file DeltaRTool.h.

m_sgName

SG::WriteHandleKey<std::vector<float> > DerivationFramework::DeltaRTool::m_sgName {this,"StoreGateEntryName","","SG key of output object"}

private

Definition at line 36 of file DeltaRTool.h.

---

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

• DeltaRTool.h
• DeltaRTool.cxx