DerivationFramework::EGTransverseMassTool Class Reference

#include <EGTransverseMassTool.h>

Inheritance diagram for DerivationFramework::EGTransverseMassTool:

Collaboration diagram for DerivationFramework::EGTransverseMassTool:

Public Member Functions
	EGTransverseMassTool (const std::string &t, const std::string &n, const IInterface *p)
virtual StatusCode	initialize () override final
virtual StatusCode	addBranches () const override final

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

Private Attributes
std::string	m_expression1
float	m_METmin
float	m_mass1Hypothesis
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.

Constructor & Destructor Documentation

EGTransverseMassTool()

DerivationFramework::EGTransverseMassTool::EGTransverseMassTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 35 of file EGTransverseMassTool.cxx.

  : base_class(t, n, p)
  , m_expression1("true")
  , m_METmin(-999.)
  , m_mass1Hypothesis(0.0)
{
  declareProperty("ObjectRequirements", m_expression1);
  declareProperty("METmin", m_METmin);
  declareProperty("ObjectMassHypothesis", m_mass1Hypothesis);
}

Member Function Documentation

addBranches()

StatusCode DerivationFramework::EGTransverseMassTool::addBranches ( ) const

finaloverridevirtual

Definition at line 83 of file EGTransverseMassTool.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
  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 99 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 49 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 51 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 57 of file EGTransverseMassTool.h.

m_expression1

std::string DerivationFramework::EGTransverseMassTool::m_expression1

private

Definition at line 42 of file EGTransverseMassTool.h.

m_mass1Hypothesis

float DerivationFramework::EGTransverseMassTool::m_mass1Hypothesis

private

Definition at line 44 of file EGTransverseMassTool.h.

m_METmin

float DerivationFramework::EGTransverseMassTool::m_METmin

private

Definition at line 43 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 71 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 85 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 64 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 78 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 46 of file EGTransverseMassTool.h.

---

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

• EGTransverseMassTool.h
• EGTransverseMassTool.cxx