DerivationFramework::InvariantMassTool Class Reference

#include <InvariantMassTool.h>

Inheritance diagram for DerivationFramework::InvariantMassTool:

Collaboration diagram for DerivationFramework::InvariantMassTool:

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	getInvariantMasses (std::vector< float > *, const EventContext &ctx) const

Static Private Member Functions
static float	calculateInvariantMass (const TVector3 &v1, const TVector3 &v2, float M1, float M2)

Private Attributes
Gaudi::Property< std::string >	m_expression {this, "ObjectRequirements", "true"}
Gaudi::Property< std::string >	m_expression2 {this, "SecondObjectRequirements", ""}
SG::WriteHandleKey< std::vector< float > >	m_sgName {this,"StoreGateEntryName","","SG key of output object"}
Gaudi::Property< float >	m_massHypothesis {this, "MassHypothesis", 0.0}
Gaudi::Property< float >	m_massHypothesis2 {this, "SecondMassHypothesis", 2.0}
SG::ReadHandleKey< xAOD::IParticleContainer >	m_containerName {this,"ContainerName","","SG key of first container"}
SG::ReadHandleKey< xAOD::IParticleContainer >	m_containerName2 {this,"SecondContainerName","","SG key of second container"}
SG::ReadDecorHandleKeyArray< xAOD::IParticleContainer >	m_inputDecorNames {this, "InputDecorNames",{},"SG keys for decorations of first (and second) container(s)"}

Detailed Description

Definition at line 26 of file InvariantMassTool.h.

Member Function Documentation

addBranches()

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

finaloverridevirtual

Definition at line 37 of file InvariantMassTool.cxx.

  {
    // Write masses to SG for access by downstream algs
    if (evtStore()->contains<std::vector<float> >(m_sgName.key())) {
      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> > masses(new std::vector<float>());
    ATH_CHECK(getInvariantMasses(masses.get(), ctx));
    SG::WriteHandle<std::vector<float> > writeHandle(m_sgName, ctx);
    ATH_CHECK(writeHandle.record(std::move(masses)));
    return StatusCode::SUCCESS;
  }

calculateInvariantMass()

float DerivationFramework::InvariantMassTool::calculateInvariantMass ( const TVector3 &  v1, const TVector3 &  v2, float  M1, float  M2  )

staticprivate

Definition at line 138 of file InvariantMassTool.cxx.

                                                                                                         {
      TLorentzVector p1(v1, M1 > 0 ? std::hypot(M1, v1.Mag()) : v1.Mag());
      TLorentzVector p2(v2, M2 > 0 ? std::hypot(M2, v2.Mag()) : v2.Mag());
      return (p1+p2).M();
 
  }

finalize()

StatusCode DerivationFramework::InvariantMassTool::finalize ( )

finaloverridevirtual

Definition at line 31 of file InvariantMassTool.cxx.

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

getInvariantMasses()

StatusCode DerivationFramework::InvariantMassTool::getInvariantMasses ( std::vector< float > *  masses, const EventContext &  ctx  ) const

private

Definition at line 51 of file InvariantMassTool.cxx.

  {
 
    // check the relevant information is available
    if (m_containerName.key().empty()) {
      ATH_MSG_WARNING("Input container missing - returning zero");
      masses->push_back(0.0);
      return StatusCode::FAILURE;
    }
 
    SG::ReadHandle<xAOD::IParticleContainer> particles{m_containerName, ctx};
 
    bool from2Collections(false);
    const xAOD::IParticleContainer* particles2{nullptr};
    if (!m_containerName2.key().empty() && m_containerName2.key()!=m_containerName.key()) {
      SG::ReadHandle<xAOD::IParticleContainer> particleHdl2{m_containerName2, ctx};
      particles2=particleHdl2.cptr();
      from2Collections = true;
    }
 
    // get the positions of the elements which pass the requirement
    std::vector<int> entries =  m_parser[kInvariantMassToolParser1]->evaluateAsVector();
    std::vector<int> entries2 =  m_parser[kInvariantMassToolParser2]->evaluateAsVector();
    unsigned int nEntries = entries.size();
    unsigned int nEntries2 = entries2.size();
 
    // check the sizes are compatible
    if (!from2Collections) {
      if ( (particles->size() != nEntries) || (particles->size() != nEntries2) || (nEntries!=nEntries2) ) {
        ATH_MSG_ERROR("Branch sizes incompatible - returning zero. Check your selection strings.");
        masses->push_back(0.0);
        return StatusCode::FAILURE;
      }
    }
    if (from2Collections) {
      if ( (particles->size() != nEntries) || (particles2->size() != nEntries2) ) {
        ATH_MSG_ERROR("Branch sizes incompatible - returning zero. Check your selection strings.");
        masses->push_back(0.0);
        return StatusCode::FAILURE;
      }
    }
 
    // Double loop to get all possible index pairs
    unsigned int outerIt, innerIt;
    std::vector<std::pair<int, int> > pairs;
    // Loop for case where both legs are from the same container
    if (!from2Collections) {
      for (outerIt=0; outerIt<nEntries; ++outerIt) {
        for (innerIt=outerIt+1; innerIt<nEntries; ++innerIt) {
          pairs.push_back({static_cast<int>(outerIt),static_cast<int>(innerIt)});
        }
      }
      // Select the pairs for which the mass should be calculated, and then calculate it
      for (const auto & [first, second]: pairs) {
        if ( (entries[first]==1 && entries2[second]==1) || (entries2[first]==1 && entries[second]==1) ) {
          const float mass = calculateInvariantMass( ((*particles)[first])->p4().Vect(),
                                                     ((*particles)[second])->p4().Vect(),
                                                     m_massHypothesis,
                                                     m_massHypothesis);
          masses->push_back(mass);
        }
      }
    }
 
    // Loop for case where both legs are from different containers
    if (from2Collections) {
      for (outerIt=0; outerIt<nEntries; ++outerIt) {
        if (entries[outerIt]==0) continue;
        for (innerIt=0; innerIt<nEntries2; ++innerIt) {
          if (entries2[innerIt]==0) continue;
          pairs.push_back({static_cast<int>(outerIt),static_cast<int>(innerIt)});
        }
      }
      // Select the pairs for which the mass should be calculated, and then calculate it
      for (const auto & [first, second]: pairs) {
        const float mass = calculateInvariantMass( ((*particles)[first])->p4().Vect(),
                                                   ((*particles2)[second])->p4().Vect(),
                                                   m_massHypothesis,
                                                   m_massHypothesis2);
        masses->push_back(mass);
      }
    }
 
    return StatusCode::SUCCESS;
 
  }

initialize()

StatusCode DerivationFramework::InvariantMassTool::initialize ( )

finaloverridevirtual

Definition at line 13 of file InvariantMassTool.cxx.

  {
    ATH_CHECK(m_sgName.initialize());
 
    if (m_expression2.empty()) {
      ATH_CHECK(initializeParser( {m_expression.value(), m_expression.value()} ));
    }
    else {
      ATH_CHECK(initializeParser( {m_expression.value(),m_expression2.value()} ));
    }
 
    ATH_CHECK(m_containerName.initialize());
    ATH_CHECK(m_containerName2.initialize(SG::AllowEmpty));
    ATH_CHECK(m_inputDecorNames.initialize(SG::AllowEmpty));
 
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_containerName

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

private

Definition at line 41 of file InvariantMassTool.h.

m_containerName2

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

private

Definition at line 42 of file InvariantMassTool.h.

m_expression

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

private

Definition at line 36 of file InvariantMassTool.h.

m_expression2

Gaudi::Property<std::string> DerivationFramework::InvariantMassTool::m_expression2 {this, "SecondObjectRequirements", ""}

private

Definition at line 37 of file InvariantMassTool.h.

m_inputDecorNames

SG::ReadDecorHandleKeyArray<xAOD::IParticleContainer> DerivationFramework::InvariantMassTool::m_inputDecorNames {this, "InputDecorNames",{},"SG keys for decorations of first (and second) container(s)"}

private

Definition at line 43 of file InvariantMassTool.h.

m_massHypothesis

Gaudi::Property<float> DerivationFramework::InvariantMassTool::m_massHypothesis {this, "MassHypothesis", 0.0}

private

Definition at line 39 of file InvariantMassTool.h.

m_massHypothesis2

Gaudi::Property<float> DerivationFramework::InvariantMassTool::m_massHypothesis2 {this, "SecondMassHypothesis", 2.0}

private

Definition at line 40 of file InvariantMassTool.h.

m_sgName

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

private

Definition at line 38 of file InvariantMassTool.h.

---

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

• InvariantMassTool.h
• InvariantMassTool.cxx