egammaTruthClassificationFillerTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id$
 
 
#include "egammaTruthClassificationFillerTool.h"
#include "xAODEgamma/Egamma.h"
#include "xAODEgamma/Electron.h"
#include "xAODEgamma/Photon.h"
#include "xAODEgamma/EgammaTruthxAODHelpers.h"
#include "AthenaKernel/errorcheck.h"
#include <cstdlib>
 
 
namespace D3PD {
 

egammaTruthClassificationFillerTool::egammaTruthClassificationFillerTool
  (const std::string& type,
   const std::string& name,
   const IInterface* parent)
    : BlockFillerTool<xAOD::Egamma> (type, name, parent),
      m_classifier ("MCTruthClassifier")
{
  declareProperty ("Classifier", m_classifier, "Classifier tool instance.");
 
  declareProperty ("DoBkgElecOrigin", m_doBkgElecOrigin = false,
                   "If true, fill in variables for the origin and type "
                   " of a photon for background electrons from conversions.");
 
  book().ignore();  // Avoid coverity warnings.
}
 

StatusCode egammaTruthClassificationFillerTool::initialize()
{
  CHECK( BlockFillerTool<xAOD::Egamma>::initialize() );
  CHECK( m_classifier.retrieve() );
  return StatusCode::SUCCESS;
}
 

StatusCode egammaTruthClassificationFillerTool::book()
{
  CHECK( addVariable ("type",      m_type,
                      "MC particle type, from classifier tool.") );
  CHECK( addVariable ("origin",    m_origin,
                      "MC particle origin, from classifier tool.") );
 
  if (m_doBkgElecOrigin) {
    CHECK( addVariable ("typebkg", m_typebkg,
                        "Type of photon for background electron "
                        "from conversions, from classifier tool") );
    CHECK( addVariable ("originbkg", m_originbkg,
                        "Origin of photon for background electron "
                        "from conversions, from classifier tool.") );
  }
 
  return StatusCode::SUCCESS;
}
 

StatusCode egammaTruthClassificationFillerTool::fill (const xAOD::Egamma& p)
{
  std::tuple<MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin, const xAOD::TruthParticle*,MCTruthPartClassifier::ParticleOutCome> res;
 
  if (const xAOD::Electron* q =
      dynamic_cast<const xAOD::Electron*>(&p))
  {
    res = m_classifier->particleTruthClassifier_full (q);
  }
  else if (const xAOD::Photon* q =
           dynamic_cast<const xAOD::Photon*>(&p))
  {
    res = m_classifier->particleTruthClassifier_full (q);
  }
  else
    std::abort();
 
  std::tie(*m_type, *m_origin, std::ignore, std::ignore) = res;
 
  if (m_doBkgElecOrigin) {
    if (std::get<0>(res) == MCTruthPartClassifier::BkgElectron &&
        std::get<1>(res) == MCTruthPartClassifier::PhotonConv &&
        std::get<2>(res))
    {
      const xAOD::TruthParticle* last = xAOD::EgammaHelpers::getBkgElectronMother(std::get<2>(res));
      if(last){
        std::tie(*m_typebkg, *m_originbkg, std::ignore, std::ignore) = m_classifier->particleTruthClassifier_full(last);
      }
    }
  }
 
  return StatusCode::SUCCESS;
}
 
 
} // namespace D3PD