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::pair<MCTruthPartClassifier::ParticleType,
    MCTruthPartClassifier::ParticleOrigin> res;
 
  MCTruthPartClassifier::Info info;
  if (const xAOD::Electron* q =
      dynamic_cast<const xAOD::Electron*>(&p))
  {
    res = m_classifier->particleTruthClassifier (q, &info);
  }
  else if (const xAOD::Photon* q =
           dynamic_cast<const xAOD::Photon*>(&p))
  {
    res = m_classifier->particleTruthClassifier (q, &info);
  }
  else
    std::abort();
 
  *m_type   = res.first;
  *m_origin = res.second;
 
  if (m_doBkgElecOrigin) {
    if (res.first == MCTruthPartClassifier::BkgElectron &&
        res.second == MCTruthPartClassifier::PhotonConv &&
        info.genPart)
    {
      const xAOD::TruthParticle* last = xAOD::EgammaHelpers::getBkgElectronMother(info.genPart);
      if(last){
        res = m_classifier->particleTruthClassifier(last, &info);
        *m_typebkg   = res.first;
        *m_originbkg = res.second;
      }
    }
  }
 
  return StatusCode::SUCCESS;
}
 
 
} // namespace D3PD