DerivationFramework::EGTransverseMassTool Class Reference

#include <EGTransverseMassTool.h>

Inheritance diagram for DerivationFramework::EGTransverseMassTool:

Collaboration diagram for DerivationFramework::EGTransverseMassTool:

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

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

Private Attributes
Gaudi::Property< std::string >	m_expression1 {this, "ObjectRequirements", "true"}
Gaudi::Property< float >	m_METmin {this, "METmin", -999.f}
Gaudi::Property< float >	m_mass1Hypothesis {this, "ObjectMassHypothesis", 0.f}
SG::WriteHandleKey< std::vector< float > >	m_sgName
SG::ReadHandleKey< xAOD::IParticleContainer >	m_container1Name
SG::ReadHandleKey< xAOD::MissingETContainer >	m_container2Name
SG::ReadHandleKey< std::vector< float > >	m_pt1BranchName
SG::ReadHandleKey< std::vector< float > >	m_phi1BranchName
SG::ReadHandleKey< std::vector< float > >	m_pt2BranchName
SG::ReadHandleKey< std::vector< float > >	m_phi2BranchName

Detailed Description

Definition at line 27 of file EGTransverseMassTool.h.

Member Function Documentation

addBranches()

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

finaloverridevirtual

Definition at line 70 of file EGTransverseMassTool.cxx.

{
  SG::WriteHandle<std::vector<float>> writeHandle{ m_sgName, ctx };
 
  // create the vector which will hold the values invariant masses
  auto masses = std::make_unique<std::vector<float>>();
  // compute the invariant mass values
  ATH_CHECK(getTransverseMasses(ctx, *masses));
 
  ATH_CHECK(writeHandle.record(std::move(masses)));
 
  return StatusCode::SUCCESS;
}

getTransverseMasses()

StatusCode DerivationFramework::EGTransverseMassTool::getTransverseMasses ( const EventContext &  ctx, std::vector< float > &  masses  ) const

private

Definition at line 85 of file EGTransverseMassTool.cxx.

{
  // Get optional payload
  const std::vector<float>* pt1 = nullptr;
  if (!m_pt1BranchName.key().empty()) {
    SG::ReadHandle<std::vector<float>> readHandle{ m_pt1BranchName, ctx };
    pt1 = readHandle.ptr();
  }
  const std::vector<float>* pt2 = nullptr;
  if (!m_pt2BranchName.key().empty()) {
    SG::ReadHandle<std::vector<float>> readHandle{ m_pt2BranchName, ctx };
    pt2 = readHandle.ptr();
  }
 
  const std::vector<float>* phi1 = nullptr;
  if (!m_phi1BranchName.key().empty()) {
    SG::ReadHandle<std::vector<float>> readHandle{ m_phi1BranchName, ctx };
    phi1 = readHandle.ptr();
  }
  const std::vector<float>* phi2 = nullptr;
  if (!m_phi2BranchName.key().empty()) {
    SG::ReadHandle<std::vector<float>> readHandle{ m_phi2BranchName, ctx };
    phi2 = readHandle.ptr();
  }
 
  // Get the input particle and MET
  SG::ReadHandle<xAOD::IParticleContainer> inputParticles1{ m_container1Name,
                                                            ctx };
  SG::ReadHandle<xAOD::MissingETContainer> inputParticles2{ m_container2Name,
                                                            ctx };
  const xAOD::IParticleContainer* particles1 = inputParticles1.ptr();
  const xAOD::MissingETContainer* particles2 = inputParticles2.ptr();
 
  // compute MET
  if (particles2->empty()) {
    if (!pt2) {
      ATH_MSG_WARNING("No MET info found");
      return StatusCode::SUCCESS;
    }
    if (pt2->empty()) {
      ATH_MSG_WARNING("No MET info found");
      return StatusCode::SUCCESS;
    }
  }
 
  float MET = pt2 ? (*pt2)[0] : particles2->at(0)->met();
  float MET_phi = phi2 ? (*phi2)[0] : particles2->at(0)->phi();
 
  // apply MET requirement
  if (MET < m_METmin)
    return StatusCode::SUCCESS;
 
  // get the positions of the particles which pass the requirement
  std::vector<int> entries1 = m_parser->evaluateAsVector();
  unsigned int nEntries1 = entries1.size();
 
  // if there are no particles in one of the two lists to combine, just leave
  // function
  if (nEntries1 == 0)
    return StatusCode::SUCCESS;
 
  // check that the sizes are compatible
  if (particles1->size() != nEntries1) {
    ATH_MSG_ERROR("Branch sizes incompatible - returning zero");
    return StatusCode::FAILURE;
  }
  if ((pt1 && pt1->size() != nEntries1) ||
      (phi1 && phi1->size() != nEntries1)) {
    ATH_MSG_ERROR("Branch sizes incompatible - returning zero");
    return StatusCode::FAILURE;
  }
 
  // Loop over the objects and calculate the transverse mass
  unsigned int iter;
  for (iter = 0; iter < nEntries1; ++iter) {
    if (entries1[iter] != 1)
      continue;
    float apt1 = pt1 ? (*pt1)[iter] : ((*particles1)[iter])->p4().Pt();
    float aphi1 = phi1 ? (*phi1)[iter] : ((*particles1)[iter])->p4().Phi();
 
    TLorentzVector v1, v2;
    v1.SetPtEtaPhiM(apt1, 0., aphi1, m_mass1Hypothesis);
    v2.SetPtEtaPhiM(MET, 0., MET_phi, 0.);
    float mass = (v1 + v2).M();
    masses.push_back(mass);
  }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::EGTransverseMassTool::initialize ( )

finaloverridevirtual

Definition at line 36 of file EGTransverseMassTool.cxx.

{
  if (m_sgName.key().empty()) {
    ATH_MSG_ERROR(
      "No SG name provided for the output of the transverse mass tool!");
    return StatusCode::FAILURE;
  }
  ATH_CHECK(m_sgName.initialize());
 
  if (!m_container1Name.key().empty()) {
    ATH_CHECK(m_container1Name.initialize());
  }
  if (!m_container2Name.key().empty()) {
    ATH_CHECK(m_container2Name.initialize());
  }
  if (!m_pt1BranchName.key().empty()) {
    ATH_CHECK(m_pt1BranchName.initialize());
  }
  if (!m_phi1BranchName.key().empty()) {
    ATH_CHECK(m_phi1BranchName.initialize());
  }
  if (!m_pt2BranchName.key().empty()) {
    ATH_CHECK(m_pt2BranchName.initialize());
  }
  if (!m_phi2BranchName.key().empty()) {
    ATH_CHECK(m_phi2BranchName.initialize());
  }
 
  ATH_CHECK(initializeParser(m_expression1));
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_container1Name

SG::ReadHandleKey<xAOD::IParticleContainer> DerivationFramework::EGTransverseMassTool::m_container1Name

private

Initial value:

{
    this,
    "ObjectContainerName",
    "",
    "SG key of first container"
  }

Definition at line 48 of file EGTransverseMassTool.h.

m_container2Name

SG::ReadHandleKey<xAOD::MissingETContainer> DerivationFramework::EGTransverseMassTool::m_container2Name

private

Initial value:

{
    this,
    "METContainerName",
    "MET_LocHadTopo",
    "SG key of second container"
  }

Definition at line 54 of file EGTransverseMassTool.h.

m_expression1

Gaudi::Property<std::string> DerivationFramework::EGTransverseMassTool::m_expression1 {this, "ObjectRequirements", "true"}

private

Definition at line 39 of file EGTransverseMassTool.h.

m_mass1Hypothesis

Gaudi::Property<float> DerivationFramework::EGTransverseMassTool::m_mass1Hypothesis {this, "ObjectMassHypothesis", 0.f}

private

Definition at line 41 of file EGTransverseMassTool.h.

m_METmin

Gaudi::Property<float> DerivationFramework::EGTransverseMassTool::m_METmin {this, "METmin", -999.f}

private

Definition at line 40 of file EGTransverseMassTool.h.

m_phi1BranchName

SG::ReadHandleKey<std::vector<float> > DerivationFramework::EGTransverseMassTool::m_phi1BranchName

private

Initial value:

{
    this,
    "ObjectPhiBranchName",
    "",
    "Phi1 if different than default"
  }

Definition at line 68 of file EGTransverseMassTool.h.

m_phi2BranchName

SG::ReadHandleKey<std::vector<float> > DerivationFramework::EGTransverseMassTool::m_phi2BranchName

private

Initial value:

{
    this,
    "METPhiBranchName",
    "",
    "Phi2 if different than default"
  }

Definition at line 82 of file EGTransverseMassTool.h.

m_pt1BranchName

SG::ReadHandleKey<std::vector<float> > DerivationFramework::EGTransverseMassTool::m_pt1BranchName

private

Initial value:

{
    this,
    "ObjectPtBranchName",
    "",
    "Pt1 if different than default"
  }

Definition at line 61 of file EGTransverseMassTool.h.

m_pt2BranchName

SG::ReadHandleKey<std::vector<float> > DerivationFramework::EGTransverseMassTool::m_pt2BranchName

private

Initial value:

{
    this,
    "METPtBranchName",
    "",
    "Pt2 if different than default"
  }

Definition at line 75 of file EGTransverseMassTool.h.

m_sgName

SG::WriteHandleKey<std::vector<float> > DerivationFramework::EGTransverseMassTool::m_sgName

private

Initial value:

{ this,
                                                   "StoreGateEntryName",
                                                   "",
                                                   "SG key of output object" }

Definition at line 43 of file EGTransverseMassTool.h.

---

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

• EGTransverseMassTool.h
• EGTransverseMassTool.cxx