removing _v1 for electron/photon class defs (xAODEgamma-00-00-81)

Event/xAOD/xAODEgamma/Root/EgammaAccessors_v1.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: EgammaAccessors_v1.cxx 582601 2014-02-11 15:46:49Z christos $
+
+// System include(s):
+#include <iostream>
+
+// Local include(s):
+#include "EgammaAccessors_v1.h"
+
+/// Helper macro for Accessor objects
+#define DEFINE_ACCESSOR(TYPE, NAME )                               \
+   case xAOD::EgammaParameters::NAME:                              \
+   {                                                               \
+     static SG::AuxElement::Accessor< TYPE > a( #NAME );	   \
+     return &a;							   \
+   }                                                               \
+   break;
+
+namespace xAOD {
+
+  /// Explicit Instantiation  of Template
+   SG::AuxElement::Accessor< float >*
+   showerShapeAccessorV1( xAOD::EgammaParameters::ShowerShapeType type ) 
+   {   
+      switch( type ) {
+        DEFINE_ACCESSOR( float, e011 );     
+        DEFINE_ACCESSOR( float, e033 );     
+        DEFINE_ACCESSOR( float, e132 );     
+        DEFINE_ACCESSOR( float, e1152 );    
+        DEFINE_ACCESSOR( float, ethad1 );   
+        DEFINE_ACCESSOR( float, ethad );    
+        DEFINE_ACCESSOR( float, ehad1 );    
+        DEFINE_ACCESSOR( float, f1 );       
+        DEFINE_ACCESSOR( float, f3 );       
+        DEFINE_ACCESSOR( float, f1core );   
+        DEFINE_ACCESSOR( float, f3core );   
+        DEFINE_ACCESSOR( float, e233 );     
+        DEFINE_ACCESSOR( float, e235 );     
+        DEFINE_ACCESSOR( float, e255 );     
+        DEFINE_ACCESSOR( float, e237 );     
+        DEFINE_ACCESSOR( float, e277 );     
+        DEFINE_ACCESSOR( float, e333 );     
+        DEFINE_ACCESSOR( float, e335 );     
+        DEFINE_ACCESSOR( float, e337 );     
+        DEFINE_ACCESSOR( float, e377 );     
+        DEFINE_ACCESSOR( float, weta1 );    
+        DEFINE_ACCESSOR( float, weta2 );    
+        DEFINE_ACCESSOR( float, e2ts1 );    
+        DEFINE_ACCESSOR( float, e2tsts1 );  
+        DEFINE_ACCESSOR( float, fracs1 );   
+        DEFINE_ACCESSOR( float, widths1 );  
+        DEFINE_ACCESSOR( float, widths2 );  
+        DEFINE_ACCESSOR( float, poscs1 );   
+        DEFINE_ACCESSOR( float, poscs2 );   
+        DEFINE_ACCESSOR( float, asy1 );     
+        DEFINE_ACCESSOR( float, pos ); 
+        DEFINE_ACCESSOR( float, pos7 ); 
+        DEFINE_ACCESSOR( float, barys1 );   
+        DEFINE_ACCESSOR( float, wtots1 );   
+        DEFINE_ACCESSOR( float, emins1 );   
+        DEFINE_ACCESSOR( float, emaxs1 );   
+        DEFINE_ACCESSOR( float, r33over37allcalo );     
+        DEFINE_ACCESSOR( float, ecore );
+        DEFINE_ACCESSOR( float, zvertex );
+        DEFINE_ACCESSOR( float, errz );
+        DEFINE_ACCESSOR( float, etap ); 
+        DEFINE_ACCESSOR( float, depth );
+      default:                  
+         std::cerr << "xAOD::Egamma_v1 ERROR Unknown float ShowerShapeType ("
+                   << type << ") requested" << std::endl;
+         return 0;
+      }
+   
+   }  
+
+   SG::AuxElement::Accessor< float >*
+   isolationAccessorV1( xAOD::EgammaParameters::IsolationType type ) 
+   {
+      switch( type ) {
+        DEFINE_ACCESSOR( float, etcone );
+        DEFINE_ACCESSOR( float, etcone15 );
+        DEFINE_ACCESSOR( float, etcone20 );
+        DEFINE_ACCESSOR( float, etcone25 );
+        DEFINE_ACCESSOR( float, etcone30 );
+        DEFINE_ACCESSOR( float, etcone35 );
+        DEFINE_ACCESSOR( float, etcone40 );
+        DEFINE_ACCESSOR( float, ptcone20 );
+        DEFINE_ACCESSOR( float, ptcone30 );
+        DEFINE_ACCESSOR( float, ptcone40 );
+        DEFINE_ACCESSOR( float, etcone15_ptcorrected );
+        DEFINE_ACCESSOR( float, etcone20_ptcorrected );
+        DEFINE_ACCESSOR( float, etcone25_ptcorrected );
+        DEFINE_ACCESSOR( float, etcone30_ptcorrected );
+        DEFINE_ACCESSOR( float, etcone35_ptcorrected );
+        DEFINE_ACCESSOR( float, etcone40_ptcorrected );
+        DEFINE_ACCESSOR( float, etcone20_corrected );
+        DEFINE_ACCESSOR( float, etcone30_corrected );
+        DEFINE_ACCESSOR( float, etcone40_corrected );
+        DEFINE_ACCESSOR( float, topoetcone20 );
+        DEFINE_ACCESSOR( float, topoetcone30 );
+        DEFINE_ACCESSOR( float, topoetcone40 );
+        DEFINE_ACCESSOR( float, topoetcone40_ptcorrected );
+        DEFINE_ACCESSOR( float, topoetcone40_corrected );
+        DEFINE_ACCESSOR( float, nucone20 );
+        DEFINE_ACCESSOR( float, nucone30 );
+        DEFINE_ACCESSOR( float, nucone40 );
+      default:
+         std::cerr << "xAOD::Egamma_v1 ERROR Unknown float IsolationType ("
+                   << type << ") requested" << std::endl;
+         return 0;
+      }
+
+   }
+
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/EgammaAccessors_v1.h

+// Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: EgammaAccessors_v1.h 582601 2014-02-11 15:46:49Z christos $
+#ifndef XAOD_EGAMMAACCESSORS_V1_H
+#define XAOD_EGAMMAACCESSORS_V1_H
+
+// EDM include(s):
+#include "AthContainers/AuxElement.h"
+// Local include(s):
+#include "xAODEgamma/EgammaEnums.h"
+
+namespace xAOD {
+
+   /// Helper function for managing Egamma Accessor objects
+   ///
+   /// This function holds on to Accessor objects that can be used by each
+   /// Egamma_v1 object at runtime to get/set detail values on themselves.
+
+
+   SG::AuxElement::Accessor< float >*
+   showerShapeAccessorV1( xAOD::EgammaParameters::ShowerShapeType type );
+
+   SG::AuxElement::Accessor< float >*
+   isolationAccessorV1( xAOD::EgammaParameters::IsolationType type );
+
+} // namespace xAOD
+
+#endif // XAOD_EGAMMAACCESSORS_V1_H

Event/xAOD/xAODEgamma/Root/EgammaAuxContainer_v1.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: EgammaAuxContainer_v1.cxx 596434 2014-05-11 17:30:02Z krasznaa $
+
+// Local include(s):
+#include "xAODEgamma/versions/EgammaAuxContainer_v1.h"
+
+namespace xAOD {
+  
+  EgammaAuxContainer_v1::EgammaAuxContainer_v1()
+    : AuxContainerBase() {
+
+    ///@name links to calo clusters 
+    AUX_VARIABLE(caloClusterLinks);
+
+
+    ///@name IParticle variables
+    AUX_VARIABLE(pt);             
+    AUX_VARIABLE(eta);           
+    AUX_VARIABLE(phi); 
+    AUX_VARIABLE(m);          
+
+    ///@name Covariance Matrix
+    AUX_VARIABLE(EgammaCovarianceMatrix);
+
+    ///@name Author    
+    AUX_VARIABLE( author );
+
+    ///@name Data Quality flag
+    AUX_VARIABLE( OQ );
+    
+    ///@name Shower Shape Details
+    AUX_VARIABLE( e011 );     
+    AUX_VARIABLE( e033 );     
+    AUX_VARIABLE( e132 );     
+    AUX_VARIABLE( e1152 );    
+    AUX_VARIABLE( ethad1 );   
+    AUX_VARIABLE( ethad );    
+    AUX_VARIABLE( ehad1 );    
+    AUX_VARIABLE( f1 );       
+    AUX_VARIABLE( f3 );       
+    AUX_VARIABLE( f1core );   
+    AUX_VARIABLE( f3core );   
+    AUX_VARIABLE( e233 );     
+    AUX_VARIABLE( e235 );     
+    AUX_VARIABLE( e255 );     
+    AUX_VARIABLE( e237 );     
+    AUX_VARIABLE( e277 );     
+    AUX_VARIABLE( e333 );     
+    AUX_VARIABLE( e335 );     
+    AUX_VARIABLE( e337 );     
+    AUX_VARIABLE( e377 );     
+    AUX_VARIABLE( weta1 );    
+    AUX_VARIABLE( weta2 );    
+    AUX_VARIABLE( e2ts1 );    
+    AUX_VARIABLE( e2tsts1 );  
+    AUX_VARIABLE( fracs1 );   
+    AUX_VARIABLE( widths1 );  
+    AUX_VARIABLE( widths2 );  
+    AUX_VARIABLE( poscs1 );   
+    AUX_VARIABLE( poscs2 );   
+    AUX_VARIABLE( asy1 );     
+    AUX_VARIABLE( pos ); 
+    AUX_VARIABLE( pos7 ); 
+    AUX_VARIABLE( barys1 );   
+    AUX_VARIABLE( wtots1 );   
+    AUX_VARIABLE( emins1 );   
+    AUX_VARIABLE( emaxs1 );   
+    AUX_VARIABLE( r33over37allcalo );     
+    AUX_VARIABLE( ecore );
+    AUX_VARIABLE( zvertex );
+    AUX_VARIABLE( errz );
+    AUX_VARIABLE( etap ); 
+    AUX_VARIABLE( depth );
+
+    ///@name ISoalation Variables
+    AUX_VARIABLE( etcone );   
+    AUX_VARIABLE( etcone15 ); 
+    AUX_VARIABLE( etcone20 ); 
+    AUX_VARIABLE( etcone25 ); 
+    AUX_VARIABLE( etcone30 ); 
+    AUX_VARIABLE( etcone35 ); 
+    AUX_VARIABLE( etcone40 ); 
+    AUX_VARIABLE( ptcone20 );
+    AUX_VARIABLE( ptcone30 );
+    AUX_VARIABLE( ptcone40 );
+    AUX_VARIABLE( nucone20 );
+    AUX_VARIABLE( nucone30 );
+    AUX_VARIABLE( nucone40 );
+    AUX_VARIABLE( etcone15_ptcorrected );
+    AUX_VARIABLE( etcone20_ptcorrected );
+    AUX_VARIABLE( etcone25_ptcorrected );
+    AUX_VARIABLE( etcone30_ptcorrected );
+    AUX_VARIABLE( etcone35_ptcorrected );
+    AUX_VARIABLE( etcone40_ptcorrected );
+    AUX_VARIABLE( etcone20_corrected );
+    AUX_VARIABLE( etcone30_corrected );
+    AUX_VARIABLE( etcone40_corrected );
+    AUX_VARIABLE( topoetcone20 );
+    AUX_VARIABLE( topoetcone30 );
+    AUX_VARIABLE( topoetcone40 );
+    AUX_VARIABLE( topoetcone40_ptcorrected );
+    AUX_VARIABLE( topoetcone40_corrected );
+   
+  }
+  
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/Egamma_v1.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: Egamma_v1$
+
+// EDM include(s):
+#include "xAODCore/AuxStoreAccessorMacros.h"
+// Local include(s):
+#include "xAODEgamma/versions/Egamma_v1.h"
+#include "EgammaAccessors_v1.h"
+
+namespace xAOD {
+
+  Egamma_v1::Egamma_v1()
+    : IParticle(), m_p4(), m_p4Cached( false ) {
+  }
+  
+  Egamma_v1::Egamma_v1(const Egamma_v1& eg) : IParticle(eg), m_p4(eg.m_p4), m_p4Cached(eg.m_p4Cached) {
+  }
+
+ Egamma_v1& Egamma_v1::operator=(const Egamma_v1& eg ){
+
+    if (this != &eg){ // protect against invalid self-assignment      
+
+      if (!this->container() && !this->hasStore() ) {      
+	  makePrivateStore();
+      }
+      this->IParticle::operator=( eg );
+      this->m_p4 = eg.m_p4;
+      this->m_p4Cached = eg.m_p4Cached;
+    }
+    // by convention, always return *this
+    return *this;
+ }
+
+
+  double Egamma_v1::pt() const {
+    static Accessor< float > acc( "pt" );
+    return acc( *this );
+  }
+  
+  double Egamma_v1::eta() const {
+    static Accessor<float > acc( "eta" );
+    return acc( *this );
+  }
+  
+  double Egamma_v1::phi() const {
+    static Accessor< float > acc( "phi" );
+    return acc( *this );
+  }
+  
+  double Egamma_v1::m() const {
+    static Accessor< float> acc( "m" );
+    return acc( *this );
+  }
+  
+  double Egamma_v1::e() const{
+    return p4().E(); 
+  }
+  
+  double Egamma_v1::rapidity() const {
+    return p4().Rapidity();	
+  }
+  
+  const Egamma_v1::FourMom_t& Egamma_v1::p4() const {
+    if( ! m_p4Cached ) {
+      m_p4.SetPtEtaPhiM( pt(), eta(), phi(),m()); 
+      m_p4Cached=true;
+    }
+    return m_p4;	
+  }
+  
+  void Egamma_v1::setP4(float pt, float eta, float phi, float m){
+    static Accessor< float > acc1( "pt" );
+    acc1( *this ) = pt;
+    static Accessor< float > acc2( "eta" );
+    acc2( *this ) = eta;
+    static Accessor< float > acc3( "phi" );
+    acc3( *this ) = phi;
+    static Accessor< float > acc4( "m" );
+    acc4( *this ) = m;
+    //Need to recalculate m_p4 if requested after update
+    m_p4Cached=false;
+  }
+  
+  void Egamma_v1::setPt(float pt){
+    static Accessor< float > acc( "pt" );
+    acc( *this ) = pt;
+    //Need to recalculate m_p4 if requested after update
+    m_p4Cached=false;
+  }
+  
+  void Egamma_v1::setEta(float eta){
+    static Accessor< float > acc( "eta" );
+    acc( *this ) = eta;
+    //Need to recalculate m_p4 if requested after update
+    m_p4Cached=false;
+  }
+
+  void Egamma_v1::setPhi(float phi){
+    static Accessor< float > acc( "phi" );
+    acc( *this ) = phi;
+    //Need to recalculate m_p4 if requested after update
+    m_p4Cached=false;
+  }
+
+  void Egamma_v1::setM(float m){
+    static Accessor< float > acc( "m" );
+    acc( *this ) = m;
+    //Need to recalculate m_p4 if requested after update
+    m_p4Cached=false;
+  }
+
+  Egamma_v1::EgammaCovMatrix_t Egamma_v1::covMatrix() const{
+    static Accessor< std::vector<float> > acc( "EgammaCovarianceMatrix" );
+    const std::vector<float>& v = acc(*this);
+    return Eigen::Map<const EgammaCovMatrix_t> (v.data());
+  }
+
+  void Egamma_v1::setCovMatrix(const Egamma_v1::EgammaCovMatrix_t& cov){
+    //The internal storage is an std::vector
+    static Accessor< std::vector < float > > acc( "EgammaCovarianceMatrix" );
+    const std::vector<float> v(cov.data(),cov.data()+16);
+    acc(*this)=v;
+  }
+  
+  uint16_t Egamma_v1::author(uint16_t mask) const {
+    static Accessor< uint16_t > acc( "author" );
+    uint16_t author = acc( *this );
+    return author & mask;
+  }
+  
+  void Egamma_v1::addAuthor(uint16_t newAuthor) {
+    static Accessor< uint16_t > acc( "author" );
+    uint16_t author = acc( *this );
+    acc( *this) = author | newAuthor;
+  }
+  
+  void Egamma_v1::setAuthor(uint16_t newAuthor) {
+    static Accessor< uint16_t > acc( "author" );
+    acc( *this) = newAuthor;
+  }
+  
+
+  
+  ///////////////
+  bool Egamma_v1::showerShapeValue(float& value, const EgammaParameters::ShowerShapeType information)  const {
+    xAOD::Egamma_v1::Accessor< float >* acc = showerShapeAccessorV1( information );
+    if( ! acc ) {
+      return false;
+    }
+    if(! acc->isAvailable( *this) ) { 
+      return  false;
+    }
+    // Retrieve the value:
+    value = ( *acc )( *this );
+    return true;
+  }
+  
+  bool Egamma_v1::setShowerShapeValue(float& value, const EgammaParameters::ShowerShapeType information){
+    xAOD::Egamma_v1::Accessor< float >* acc = showerShapeAccessorV1( information );
+     if( ! acc ) return false;
+    // Set the value:
+    ( *acc )( *this ) = value;
+    return true;
+
+  }
+   
+  
+  ///////////////
+  bool  Egamma_v1::isolationValue(float& value, const EgammaParameters::IsolationType information)  const {
+
+    xAOD::Egamma_v1::Accessor< float >* acc = isolationAccessorV1( information );
+    if( ! acc ) {
+      return false;
+    }
+    if(! acc->isAvailable( *this) ) {
+      return  false;
+    }
+    // Retrieve the value:
+    value = ( *acc )( *this );
+    return true;
+  }
+
+  bool Egamma_v1::setIsolationValue(float& value, const EgammaParameters::IsolationType information) {
+
+     xAOD::Egamma_v1::Accessor< float >* acc = isolationAccessorV1( information );
+     if( ! acc ) return false;
+     // Set the value:
+     ( *acc )( *this ) = value;
+     return true;
+
+  }
+
+
+  ////////////////////////////////////////////////////
+  /// Implementation of the CaloCluster accessor functions
+
+  size_t Egamma_v1::nCaloClusters() const {
+
+     static SG::AuxElement::Accessor< Egamma_v1::CLELVec_t >
+        clusterAcc( "caloClusterLinks" );
+
+     if( clusterAcc.isAvailable( *this ) ) {
+        return clusterAcc( *this ).size();
+     }
+     return 0;
+  }
+
+  const xAOD::CaloCluster* Egamma_v1::caloCluster( size_t index ) const {
+    
+     if( index >= nCaloClusters() ) {
+        return 0;
+     }
+     const CLELVec_t& cls = caloClusterLinks();
+     if( ! cls[ index ].isValid() ) {
+        return 0;
+     }
+     return *( cls[ index ] );
+  }
+
+  const ElementLink< CaloClusterContainer >&
+  Egamma_v1::caloClusterLink( size_t index ) const {
+
+     if( index >= nCaloClusters() ) {
+        static const ElementLink< CaloClusterContainer > dummy;
+        return dummy;
+     }
+     return caloClusterLinks()[ index ];
+  }
+
+  AUXSTORE_OBJECT_SETTER_AND_GETTER( Egamma_v1, Egamma_v1::CLELVec_t,
+                                     caloClusterLinks, setCaloClusterLinks )
+
+  ///////////
+
+  bool Egamma_v1::isGoodOQ(uint32_t mask) const {
+    static Accessor< uint32_t > acc( "OQ" );
+    uint32_t OQ = acc( *this );
+    return OQ & mask;
+  }
+  
+  void Egamma_v1::setOQ(uint32_t newOQ) {
+    static Accessor< uint32_t > acc( "OQ" );
+    acc( *this) = newOQ;
+  }
+
+  ///////////
+  bool Egamma_v1::passSelection(bool&  value, const std::string& menu ) const {
+    SG::AuxElement::Accessor< char > acc( menu );
+    if(! acc.isAvailable( *this) ) { return  false;}
+    value= (acc)( *this );
+    return true;
+  }
+
+  void Egamma_v1::setPassSelection(bool value, const std::string& menu){
+    SG::AuxElement::Accessor< char > acc( menu );
+    ( acc )( *this )=value;
+    return;
+  }
+  
+
+} // namespace xAOD
+
+//  LocalWords:  const el hasStore makePrivateStore

Event/xAOD/xAODEgamma/Root/EgammaxAODHelpers.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "xAODEgamma/EgammaxAODHelpers.h"
+
+#include "xAODEgamma/Egamma.h"
+#include "xAODEgamma/Electron.h"
+#include "xAODEgamma/Photon.h"
+
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODEgamma/PhotonContainer.h"
+
+
+#include "xAODTracking/Vertex.h"
+#include "xAODTracking/TrackParticle.h"
+#include "xAODCaloEvent/CaloCluster.h"
+
+bool xAOD::EgammaHelpers::isElectron(const xAOD::Egamma *eg){
+  return ( (eg->type()==xAOD::Type::Electron) && 
+	   (!eg->author(xAOD::EgammaParameters::AuthorFwdElectron)));
+}
+
+
+bool xAOD::EgammaHelpers::isFwdElectron(const xAOD::Egamma *eg){
+  return eg->author(xAOD::EgammaParameters::AuthorFwdElectron);
+}
+
+bool xAOD::EgammaHelpers::isPhoton(const xAOD::Egamma *eg){
+  return (eg->type()==xAOD::Type::Photon);
+}
+
+bool xAOD::EgammaHelpers::isConvertedPhoton(const xAOD::Egamma *eg){
+  const xAOD::Photon *ph = dynamic_cast<const xAOD::Photon*>(eg);
+  return (ph && (ph->nVertices()>0) );
+}
+
+// ==================================================================
+size_t xAOD::EgammaHelpers::numberOfSiHits(const xAOD::TrackParticle *tp)
+{
+  if (!tp) return 0;
+  
+  uint8_t dummy(0), nSiHits(0);
+  if (tp->summaryValue(dummy, xAOD::numberOfPixelHits))
+    nSiHits += dummy;
+  if (tp->summaryValue(dummy, xAOD::numberOfSCTHits))
+    nSiHits += dummy;
+  return nSiHits;
+}  
+
+// ==================================================================
+bool xAOD::EgammaHelpers::isBarrel(const xAOD::Egamma *eg)
+{
+  return (eg ? isBarrel(eg->caloCluster()) : false);
+}
+
+bool xAOD::EgammaHelpers::isBarrel(const xAOD::CaloCluster *cluster)
+{
+  if (cluster->inBarrel() &&  cluster->inEndcap()){
+    return  cluster->eSample(CaloSampling::EMB2) >= cluster->eSample(CaloSampling::EME2);
+  }
+  return cluster->inBarrel();
+}
+
+// ==================================================================
+const std::set<const xAOD::TrackParticle*> xAOD::EgammaHelpers::getTrackParticles(const xAOD::Egamma *eg, 
+  bool useBremAssoc /* = true */, bool allParticles /* = true */)
+{  
+  if (!eg) return std::set<const xAOD::TrackParticle*>();
+
+  if (eg->type()==xAOD::Type::Electron) {
+    const xAOD::Electron* el = static_cast<const xAOD::Electron*> (eg);
+    if (el) return getTrackParticles(el, useBremAssoc, allParticles);
+  }
+  if (eg->type()==xAOD::Type::Photon) {
+    const xAOD::Photon* ph = static_cast<const xAOD::Photon*> (eg);  
+    if (ph) return getTrackParticles(ph, useBremAssoc);
+  }
+
+  std::cerr << "egamma object not electron nor photon" << std::endl;
+  return std::set<const xAOD::TrackParticle*>();
+}
+
+// ==================================================================
+const std::set<const xAOD::TrackParticle*> xAOD::EgammaHelpers::getTrackParticles(const xAOD::Electron* el, 
+  bool useBremAssoc /* = true */, bool allParticles /* = true */)
+{
+  std::set<const xAOD::TrackParticle*> tps;
+  for (unsigned int i = 0; i < el->nTrackParticles(); ++i)
+  {
+    const xAOD::TrackParticle* tp = el->trackParticle(i);
+    if (useBremAssoc) tp = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(tp);
+    if (tp) tps.insert( tp );
+    if (!allParticles) break; // break after first particle
+  }
+  return tps;
+}
+
+// ==================================================================
+const std::set<const xAOD::TrackParticle*> xAOD::EgammaHelpers::getTrackParticles(const xAOD::Photon* ph,
+  bool useBremAssoc /* = true */)
+{
+  std::set<const xAOD::TrackParticle*> tps;
+  if (!ph) return tps;
+  const xAOD::Vertex* vx = ph->vertex();
+  for (unsigned int i=0; vx && i < vx->nTrackParticles(); ++i)
+  {
+    const xAOD::TrackParticle *tp = vx->trackParticle(i);
+    tps.insert( useBremAssoc ? xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(tp) : tp );
+  }
+  return tps;
+}
+
+// ==================================================================
+
+const xAOD::TruthParticle* xAOD::EgammaHelpers::getTruthParticle(const xAOD::IParticle* particle, bool debug)
+{
+  return getLink<xAOD::TruthParticle>(particle, "truthParticleLink", debug);
+}
+
+const xAOD::Electron* xAOD::EgammaHelpers::getRecoElectron(const xAOD::TruthParticle* particle, bool debug)
+{
+  return getLink<xAOD::Electron>(particle, "recoElectronLink", debug);
+}
+
+const xAOD::Photon* xAOD::EgammaHelpers::getRecoPhoton(const xAOD::TruthParticle* particle, bool debug)
+{
+  return getLink<xAOD::Photon>(particle, "recoPhotonLink", debug);
+}
+

Event/xAOD/xAODEgamma/Root/ElectronAccessors_v1.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: ElectronAccessors_v1.cxx 575466 2013-12-13 16:40:29Z amorley $
+
+// System include(s):
+#include <iostream>
+
+// Local include(s):
+#include "ElectronAccessors_v1.h"
+
+/// Helper macro for Accessor objects
+#define DEFINE_ACCESSOR(TYPE, NAME )                               \
+  case xAOD::EgammaParameters::NAME:				   \
+   {                                                               \
+     static SG::AuxElement::Accessor< TYPE > a( #NAME );	   \
+     return &a;							   \
+   }                                                               \
+   break;
+
+namespace xAOD {
+
+   SG::AuxElement::Accessor< float >*
+   trackCaloMatchAccessorV1( xAOD::EgammaParameters::TrackCaloMatchType type ) 
+   {   
+      switch( type ) {
+        DEFINE_ACCESSOR( float,deltaEta0);
+        DEFINE_ACCESSOR( float,deltaEta1);
+        DEFINE_ACCESSOR( float,deltaEta2);
+        DEFINE_ACCESSOR( float,deltaEta3);
+        DEFINE_ACCESSOR( float,deltaPhi0);
+        DEFINE_ACCESSOR( float,deltaPhi1);
+        DEFINE_ACCESSOR( float,deltaPhi2);
+        DEFINE_ACCESSOR( float,deltaPhi3);
+        DEFINE_ACCESSOR( float,deltaPhiFromLastMeasurement);
+        DEFINE_ACCESSOR( float,deltaPhiRescaled0);
+        DEFINE_ACCESSOR( float,deltaPhiRescaled1);
+        DEFINE_ACCESSOR( float,deltaPhiRescaled2);
+        DEFINE_ACCESSOR( float,deltaPhiRescaled3);;
+      default:                  
+         std::cerr << "xAOD::Electron_v1 ERROR Unknown float TrackCaloMatchType ("
+                   << type << ") requested" << std::endl;
+         return 0;
+      }
+   
+   }     
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/ElectronAccessors_v1.h

+// Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: ElectronAccessors_v1.h 575464 2013-12-13 16:28:44Z christos $
+#ifndef XAOD_ELECTRONACCESSORS_V1_H
+#define XAOD_ELECTRONACCESSORS_V1_H
+
+// EDM include(s):
+#include "AthContainers/AuxElement.h"
+// Local include(s):
+#include "xAODEgamma/EgammaEnums.h"
+
+namespace xAOD {
+
+   /// Helper function for managing Egamma Accessor objects
+   ///
+   /// This function holds on to Accessor objects that can be used by each
+   /// Electron_v1 object at runtime to get/set detail values on themselves.
+
+   SG::AuxElement::Accessor< float >*
+   trackCaloMatchAccessorV1( xAOD::EgammaParameters::TrackCaloMatchType type );
+
+
+} // namespace xAOD
+
+#endif // XAOD_ELECTRONACCESSORS_V1_H

Event/xAOD/xAODEgamma/Root/ElectronAuxContainer_v1.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: ElectronAuxContainer_v1.cxx 597503 2014-05-16 16:34:05Z christos $
+
+// Local include(s):
+#include "xAODEgamma/versions/ElectronAuxContainer_v1.h"
+
+
+namespace xAOD {
+  
+  ElectronAuxContainer_v1::ElectronAuxContainer_v1()
+    : EgammaAuxContainer_v1() {
+
+
+    ///@links to track Particles
+    AUX_VARIABLE(trackParticleLinks);
+
+    ///@name Electron Charge
+    ///@{
+    AUX_VARIABLE(charge);
+    ///@}
+
+    /// @name Track Match details
+    /// @{
+    AUX_VARIABLE(deltaEta0);
+    AUX_VARIABLE(deltaEta1);
+    AUX_VARIABLE(deltaEta2);
+    AUX_VARIABLE(deltaEta3);
+    AUX_VARIABLE(deltaPhi0);
+    AUX_VARIABLE(deltaPhi1);
+    AUX_VARIABLE(deltaPhi2);
+    AUX_VARIABLE(deltaPhi3);
+    AUX_VARIABLE(deltaPhiRescaled0);
+    AUX_VARIABLE(deltaPhiRescaled1);
+    AUX_VARIABLE(deltaPhiRescaled2);
+    AUX_VARIABLE(deltaPhiRescaled3);
+    AUX_VARIABLE(deltaPhiFromLastMeasurement);
+    ///@}
+
+
+
+
+    }
+  
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/ElectronAuxContainer_v2.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: ElectronAuxContainer_v2.cxx 614829 2014-09-03 09:39:36Z krasznaa $
+
+// Local include(s):
+#include "xAODEgamma/versions/ElectronAuxContainer_v2.h"
+
+namespace xAOD {
+  
+   ElectronAuxContainer_v2::ElectronAuxContainer_v2()
+      : AuxContainerBase() {
+
+/// Include the egamma variables:
+#define EGAMMA_AUX_VARIABLE( TYPE, NAME ) AUX_VARIABLE( NAME )
+#include "xAODEgamma/versions/EgammaAuxVariables_v2.def"
+#undef EGAMMA_AUX_VARIABLE
+
+      ///@links to track Particles
+      AUX_VARIABLE(trackParticleLinks);
+
+      ///@name Electron Charge
+      ///@{
+      AUX_VARIABLE(charge);
+      ///@}
+
+      /// @name Track Match details
+      /// @{
+      AUX_VARIABLE(deltaEta0);
+      AUX_VARIABLE(deltaEta1);
+      AUX_VARIABLE(deltaEta2);
+      AUX_VARIABLE(deltaEta3);
+      AUX_VARIABLE(deltaPhi0);
+      AUX_VARIABLE(deltaPhi1);
+      AUX_VARIABLE(deltaPhi2);
+      AUX_VARIABLE(deltaPhi3);
+      AUX_VARIABLE(deltaPhiRescaled0);
+      AUX_VARIABLE(deltaPhiRescaled1);
+      AUX_VARIABLE(deltaPhiRescaled2);
+      AUX_VARIABLE(deltaPhiRescaled3);
+      AUX_VARIABLE(deltaPhiFromLastMeasurement);
+      ///@}
+   }
+  
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/Electron_v1.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: Electron_v1$
+
+// EDM include(s):
+#include "xAODCore/AuxStoreAccessorMacros.h"
+
+// Local include(s):
+#include "xAODEgamma/versions/Electron_v1.h"
+#include "ElectronAccessors_v1.h"
+
+namespace xAOD {
+
+  Electron_v1::Electron_v1() : Egamma_v1() {
+
+  }
+
+  Electron_v1::Electron_v1(const Electron_v1& el) : Egamma_v1(el){
+    this->makePrivateStore(el);  
+  }
+ 
+  Electron_v1& Electron_v1::operator=(const Electron_v1& el ){
+
+    if (this != &el){ // protect against invalid self-assignment      
+      this->Egamma_v1::operator=( el );
+    }
+    // by convention, always return *this
+    return *this;
+  }
+
+  AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( Electron_v1, float, charge, setCharge )
+
+  Type::ObjectType Electron_v1::type() const {
+
+    return Type::Electron;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  //         Implementation of the TrackParticle accessor functions
+  //
+
+  size_t xAOD::Electron_v1::nTrackParticles() const {
+
+     static SG::AuxElement::Accessor< Electron_v1::TPELVec_t >
+        trackAcc( "trackParticleLinks" );
+
+     if( trackAcc.isAvailable( *this ) ) {
+        return trackAcc( *this ).size();
+     }
+     return 0;
+  }
+
+  const xAOD::TrackParticle* Electron_v1::trackParticle( size_t index ) const {
+
+     if( index >= nTrackParticles() ) {
+        return 0;
+     }
+     const TPELVec_t& links = trackParticleLinks();
+     if( ! links[ index ].isValid() ) {
+        return 0;
+     }
+     return *( links[ index ] );
+  }
+
+  const ElementLink< TrackParticleContainer >&
+  Electron_v1::trackParticleLink( size_t index ) const {
+
+     if( index >= nTrackParticles() ) {
+        static const ElementLink< TrackParticleContainer > dummy;
+        return dummy;
+     }
+     return trackParticleLinks()[ index ];
+  }
+
+  AUXSTORE_OBJECT_SETTER_AND_GETTER( Electron_v1, Electron_v1::TPELVec_t,
+                                     trackParticleLinks, setTrackParticleLinks )
+
+  //
+  //////////////////////////////////////////////////////////////////////////////
+
+  /////////////////////////////////////////////////////////////////////////////
+  //Implementation of the summary value accessor functions
+  
+  bool Electron_v1::trackCaloMatchValue( float& value, const EgammaParameters::TrackCaloMatchType information ) const {
+
+    xAOD::Electron_v1::Accessor< float >* acc = trackCaloMatchAccessorV1( information );
+    if( ! acc ) { 
+      return false;
+    }
+    if(! acc->isAvailable( *this) ){
+      return  false;
+    }
+    // Retrieve the value:
+    value = ( *acc )( *this );
+    return true;
+  }
+
+  bool Electron_v1::setTrackCaloMatchValue( float& value, const EgammaParameters::TrackCaloMatchType information ) {
+
+    xAOD::Electron_v1::Accessor< float >* acc = trackCaloMatchAccessorV1( information );
+     if( ! acc ) return false;
+    // Set the value:
+    ( *acc )( *this ) = value;
+    return true;
+  }
+
+
+  bool Electron_v1::trackParticleSummaryValue( uint8_t& value, const SummaryType information, int index ) const {
+
+    const xAOD::TrackParticle* tempTrackParticle = trackParticle(index);
+    if (!tempTrackParticle) return false;
+    return tempTrackParticle->summaryValue(value,information);
+  }
+
+  bool Electron_v1::trackParticleSummaryValue( float& value, const SummaryType information, int index ) const {
+    
+    const xAOD::TrackParticle* tempTrackParticle = trackParticle(index);
+    if (!tempTrackParticle) return false;
+    return tempTrackParticle->summaryValue(value,information);
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+
+
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/ElectronxAODHelpers.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "xAODEgamma/ElectronxAODHelpers.h"
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/TrackParticleContainer.h"
+
+const xAOD::TrackParticle* xAOD::EgammaHelpers::getOriginalTrackParticle(const xAOD::Electron* el){
+
+ if(el){
+    const xAOD::TrackParticle* trkPar= el->trackParticle();
+    if(trkPar){
+      return getOriginalTrackParticleFromGSF(trkPar);
+    }
+  }
+  return 0;
+}
+
+const xAOD::TrackParticle* xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(const xAOD::TrackParticle* trkPar){
+
+  if(! trkPar) return 0;
+  static SG::AuxElement::Accessor<ElementLink<xAOD::TrackParticleContainer> > orig ("originalTrackParticle");
+
+  if (!orig.isAvailable(*trkPar) || !orig(*trkPar).isValid()) return 0;
+
+  return (*orig(*trkPar));
+}
+

Event/xAOD/xAODEgamma/Root/PhotonAccessors_v1.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: PhotonAccessors_v1.cxx 582601 2014-02-11 15:46:49Z christos $
+
+// System include(s):
+#include <iostream>
+
+// Local include(s):
+#include "PhotonAccessors_v1.h"
+
+/// Helper macro for Accessor objects
+#define DEFINE_ACCESSOR(TYPE, NAME )                               \
+  case xAOD::EgammaParameters::NAME:				   \
+   {                                                               \
+     static SG::AuxElement::Accessor< TYPE > a( #NAME );	   \
+     return &a;							   \
+   }                                                               \
+   break;
+
+namespace xAOD {
+
+   SG::AuxElement::Accessor< float >*
+   vertexCaloMatchAccessorV1( xAOD::EgammaParameters::VertexCaloMatchType type ) 
+   {   
+      switch( type ) {
+	DEFINE_ACCESSOR( float,convMatchDeltaEta1);
+	DEFINE_ACCESSOR( float,convMatchDeltaEta2);    
+	DEFINE_ACCESSOR( float,convMatchDeltaPhi1);    
+	DEFINE_ACCESSOR( float,convMatchDeltaPhi2);
+      default:                  
+         std::cerr << "xAOD::Photon_v1 ERROR Unknown float VertexCaloMatchType ("
+                   << type << ") requested" << std::endl;
+         return 0;
+      }
+   
+   }     
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/PhotonAccessors_v1.h

+// Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: PhotonAccessors_v1.h 582601 2014-02-11 15:46:49Z christos $
+#ifndef XAOD_PHOTONACCESSORS_V1_H
+#define XAOD_PHOTONACCESSORS_V1_H
+
+// EDM include(s):
+#include "AthContainers/AuxElement.h"
+// Local include(s):
+#include "xAODEgamma/EgammaEnums.h"
+
+namespace xAOD {
+
+   /// Helper function for managing Egamma Accessor objects
+   ///
+   /// This function holds on to Accessor objects that can be used by each
+   /// Photon_v1 object at runtime to get/set detail values on themselves.
+
+   SG::AuxElement::Accessor< float >*
+   vertexCaloMatchAccessorV1( xAOD::EgammaParameters::VertexCaloMatchType type );
+
+
+} // namespace xAOD
+
+#endif // XAOD_PHOTONACCESSORS_V1_H

Event/xAOD/xAODEgamma/Root/PhotonAuxContainer_v1.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: PhotonAuxContainer_v1.cxx 596434 2014-05-11 17:30:02Z krasznaa $
+
+// xAOD include(s):
+#include "xAODTracking/TrackParticleContainer.h"
+
+// Local include(s):
+#include "xAODEgamma/versions/PhotonAuxContainer_v1.h"
+
+namespace xAOD {
+
+   PhotonAuxContainer_v1::PhotonAuxContainer_v1()
+      : EgammaAuxContainer_v1() {
+
+      ///@links to track Particles
+      AUX_VARIABLE(vertexLinks);
+
+      /// @name Vertex Match details
+      /// @{
+
+      AUX_VARIABLE(convMatchDeltaEta1);
+      AUX_VARIABLE(convMatchDeltaEta2);    
+      AUX_VARIABLE(convMatchDeltaPhi1);    
+      AUX_VARIABLE(convMatchDeltaPhi2);
+      
+      ///@}
+
+
+   }
+
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/PhotonAuxContainer_v2.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: PhotonAuxContainer_v2.cxx 614853 2014-09-03 11:40:46Z krasznaa $
+
+// Local include(s):
+#include "xAODEgamma/versions/PhotonAuxContainer_v2.h"
+
+namespace xAOD {
+
+   PhotonAuxContainer_v2::PhotonAuxContainer_v2()
+      : AuxContainerBase() {
+
+/// Include the egamma variables:
+#define EGAMMA_AUX_VARIABLE( TYPE, NAME ) AUX_VARIABLE( NAME )
+#include "xAODEgamma/versions/EgammaAuxVariables_v2.def"
+#undef EGAMMA_AUX_VARIABLE
+
+      /// Links to track particles
+      AUX_VARIABLE(vertexLinks);
+
+      /// @name Vertex Match details
+      /// @{
+
+      AUX_VARIABLE(convMatchDeltaEta1);
+      AUX_VARIABLE(convMatchDeltaEta2);    
+      AUX_VARIABLE(convMatchDeltaPhi1);    
+      AUX_VARIABLE(convMatchDeltaPhi2);
+      
+      /// @}
+   }
+
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/Photon_v1.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: Photon_v1.cxx 612240 2014-08-18 11:04:15Z christos $
+
+// EDM include(s):
+#include "xAODCore/AuxStoreAccessorMacros.h"
+
+// Local include(s):
+#include "xAODEgamma/versions/Photon_v1.h"
+#include "PhotonAccessors_v1.h"
+
+namespace xAOD {
+
+   Photon_v1::Photon_v1()
+      : Egamma_v1() {
+
+   }
+
+  Photon_v1::Photon_v1(const Photon_v1& ph) : Egamma_v1(ph){
+    makePrivateStore(ph);  
+  }
+
+  Photon_v1& Photon_v1::operator=(const Photon_v1& ph ){
+
+    if (this != &ph){ // protect against invalid self-assignment      
+      this->Egamma_v1::operator=( ph );
+    }
+    // by convention, always return *this
+    return *this;
+  }  
+
+
+   Type::ObjectType Photon_v1::type() const {
+
+      return Type::Photon;
+   }
+
+   /////////////////////////////////////////////////////////////////////////////
+   //
+   //       Implementation of the vertex handling functions
+   //
+
+   const xAOD::Vertex* Photon_v1::vertex( size_t index ) const {
+
+      if( index >= nVertices() ) {
+         return 0;
+      }
+      const VxELVec_t& links = vertexLinks();
+      if( ! links[ index ].isValid() ) {
+         return 0;
+      }
+      return *( links[ index ] );
+   }
+
+   const ElementLink< VertexContainer >&
+   Photon_v1::vertexLink( size_t index ) const {
+
+      if( index >= nVertices() ) {
+         static const ElementLink< VertexContainer > dummy;
+         return dummy;
+      }
+      return vertexLinks()[ index ];
+   }
+
+   AUXSTORE_OBJECT_SETTER_AND_GETTER( Photon_v1, Photon_v1::VxELVec_t,
+                                      vertexLinks, setVertexLinks )
+
+   size_t xAOD::Photon_v1::nVertices() const {
+
+      static SG::AuxElement::Accessor< Photon_v1::VxELVec_t >
+         vertexAcc( "vertexLinks" );
+
+      if( vertexAcc.isAvailable( *this ) ) {
+         return vertexAcc( *this ).size();
+      }
+      return 0;
+   }
+
+   //
+   /////////////////////////////////////////////////////////////////////////////
+
+  /////////////////////////////////////////////////////////////////////////////
+  //Implementation of the summary value accessor functions
+
+  bool Photon_v1::vertexCaloMatchValue( float& value, const EgammaParameters::VertexCaloMatchType information ) const {
+
+    xAOD::Photon_v1::Accessor< float >* acc = vertexCaloMatchAccessorV1( information );
+    if( ! acc ) { 
+      return false;
+    }
+    if(! acc->isAvailable( *this) ) {
+      return  false;
+    }
+    // Retrieve the value:
+    value = ( *acc )( *this );
+    return true;
+  }
+
+  bool Photon_v1::setVertexCaloMatchValue( float& value, const EgammaParameters::VertexCaloMatchType information ) {
+
+    xAOD::Photon_v1::Accessor< float >* acc =  vertexCaloMatchAccessorV1( information );
+    if( ! acc ) return false;
+    // Set the value:
+    ( *acc )( *this ) = value;
+    return true;
+  }
+   /////////////////////////////////////////////////////////////////////////////
+
+
+} // namespace xAOD

Event/xAOD/xAODEgamma/Root/PhotonxAODHelpers.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "xAODEgamma/PhotonxAODHelpers.h"
+#include "xAODEgamma/EgammaxAODHelpers.h"
+#include "xAODEgamma/Photon.h"
+#include<cmath>
+
+// ==================================================================
+
+bool xAOD::EgammaHelpers::isConvertedPhoton(const xAOD::Photon *ph){
+  return (ph && (ph->nVertices()>0) );
+}
+
+xAOD::EgammaParameters::ConversionType xAOD::EgammaHelpers::conversionType(const xAOD::Photon *ph){
+  if (!ph) return xAOD::EgammaParameters::NumberOfVertexConversionTypes;
+  return conversionType(ph->vertex());
+}
+
+xAOD::EgammaParameters::ConversionType xAOD::EgammaHelpers::conversionType(const xAOD::Vertex *vx){
+  if (!vx) return xAOD::EgammaParameters::unconverted;
+
+  const TrackParticle *trk1 = ( vx->nTrackParticles() ? vx->trackParticle(0) : 0 );
+  const TrackParticle *trk2 = ( vx->nTrackParticles() > 1 ? vx->trackParticle(1) : 0 );
+  uint8_t nSiHits1 = numberOfSiHits(trk1);
+  uint8_t nSiHits2 = numberOfSiHits(trk2);
+
+  if (!trk1) return xAOD::EgammaParameters::unconverted;
+
+  if (!trk2)
+    return nSiHits1 ? xAOD::EgammaParameters::singleSi : xAOD::EgammaParameters::singleTRT;
+  
+  if (nSiHits1 && nSiHits2)
+    return xAOD::EgammaParameters::doubleSi;
+  else if (nSiHits1 || nSiHits2)
+    return xAOD::EgammaParameters::doubleSiTRT;  
+  else
+    return xAOD::EgammaParameters::doubleTRT;
+}
+
+// ==================================================================
+
+size_t xAOD::EgammaHelpers::numberOfSiTracks(const xAOD::Photon *ph){
+  if (!ph || !ph->vertex()) return 0;
+  return numberOfSiTracks(ph->vertex());
+}
+
+size_t xAOD::EgammaHelpers::numberOfSiTracks(const xAOD::Vertex *vx)
+{
+  if (!vx) return 0;
+  return numberOfSiTracks(conversionType(vx));
+}
+
+size_t xAOD::EgammaHelpers::numberOfSiTracks(const xAOD::EgammaParameters::ConversionType convType)
+{
+  if (convType == xAOD::EgammaParameters::doubleSi) return 2;
+  if (convType == xAOD::EgammaParameters::singleSi ||
+      convType == xAOD::EgammaParameters::doubleSiTRT) return 1;
+  return 0;
+}
+
+// ==================================================================
+
+float xAOD::EgammaHelpers::conversionRadius(const xAOD::Vertex* vx)
+{
+  if (!vx) return 9999.;
+  return sqrt( vx->x()*vx->x() + vx->y()*vx->y() );
+}
+
+float xAOD::EgammaHelpers::conversionRadius(const xAOD::Photon* ph)
+{
+  if (!ph || !ph->vertex()) return 9999.;
+  return conversionRadius(ph->vertex());
+}
+
+// ==================================================================
+
+Amg::Vector3D xAOD::EgammaHelpers::momentumAtVertex(const xAOD::Photon *photon, bool debug)
+{
+  if (!photon || !photon->vertex()) return Amg::Vector3D(0., 0., 0.);
+  return momentumAtVertex(*photon->vertex(), debug);
+}
+  
+
+Amg::Vector3D xAOD::EgammaHelpers::momentumAtVertex(const xAOD::Vertex& vertex, bool debug)
+{  
+  if (isAvailable(vertex, "px") && 
+      isAvailable(vertex, "py") && 
+      isAvailable(vertex, "pz") )
+  {
+    return Amg::Vector3D( vertex.auxdata<float>("px"),
+                          vertex.auxdata<float>("py"),
+                          vertex.auxdata<float>("pz") );
+  }
+  else if (debug)
+    std::cout << "Vertex not decorated with momentum" << std::endl;
+  
+  return Amg::Vector3D(0., 0., 0.);
+}
+
+bool xAOD::EgammaHelpers::isAvailable(const xAOD::Vertex& vertex, std::string name)
+{
+  SG::AuxElement::Accessor<float> acc(name, "");
+  return acc.isAvailable(vertex); 
+}

Event/xAOD/xAODEgamma/Root/dict/ContainerProxies.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: ContainerProxies.cxx 575944 2013-12-17 15:07:13Z christos $
+
+// EDM include(s):
+#include "xAODCore/AddDVProxy.h"
+
+// Local include(s):
+#include "xAODEgamma/versions/ElectronContainer_v1.h"
+#include "xAODEgamma/versions/PhotonContainer_v1.h"
+
+// Set up the collection proxies:
+ADD_NS_DV_PROXY( xAOD, ElectronContainer_v1 );
+ADD_NS_DV_PROXY( xAOD, PhotonContainer_v1 );

Event/xAOD/xAODEgamma/cmt/Makefile.RootCore

+# this makefile also gets parsed by shell scripts
+# therefore it does not support full make syntax and features
+# edit with care
+
+# for full documentation check:
+# https://twiki.cern.ch/twiki/bin/viewauth/Atlas/RootCore#Package_Makefile
+
+PACKAGE          = xAODEgamma
+PACKAGE_PRELOAD  =
+PACKAGE_CXXFLAGS = 
+PACKAGE_OBJFLAGS = 
+PACKAGE_LDFLAGS  = 
+PACKAGE_BINFLAGS = 
+PACKAGE_LIBFLAGS = 
+PACKAGE_DEP      = AthContainers AthLinks EventPrimitives GeoPrimitives xAODBase xAODCore xAODTracking xAODCaloEvent xAODTruth
+PACKAGE_TRYDEP   = 
+PACKAGE_CLEAN    = 
+PACKAGE_NOGRID   = 
+PACKAGE_PEDANTIC = 0
+PACKAGE_NOOPT    = 0
+PACKAGE_NOCC     = 0
+PACKAGE_REFLEX   = 1
+
+include $(ROOTCOREDIR)/Makefile-common

Event/xAOD/xAODEgamma/cmt/requirements

+package xAODEgamma
+
+author Jovan Mitrevski <Jovan.Mitrevski@cern.ch>
+author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
+author Christos Anastopoulos <Christos.Anastopoulos@cern.ch>
+author Anthony Morley <Anthony.Morley@cern.ch>
+author Bruno Lenzi <Bruno.Lenzi@cern.ch>
+
+public
+
+# Central package(s):
+use AtlasPolicy   AtlasPolicy-*
+use SGTools       SGTools-*       Control
+use AthContainers AthContainers-* Control
+use AtlasROOT     AtlasROOT-*     External
+use AthLinks      AthLinks-*      Control
+
+# The code needs libGenVector.so...
+macro xAODEgamma_extra_libs "-lGenVector"
+macro_append xAODEgammalinkopts   " $(xAODEgamma_extra_libs) "
+macro_append xAODEgamma_shlibflags " $(xAODEgamma_extra_libs) "
+
+# EDM package(s):
+use xAODBase		xAODBase-*		Event/xAOD
+use xAODCore      	xAODCore-*		Event/xAOD
+use xAODCaloEvent       xAODCaloEvent-*         Event/xAOD
+use xAODTracking        xAODTracking-*          Event/xAOD
+use xAODTruth           xAODTruth-*             Event/xAOD
+
+#Eigen/Amg includes
+use EventPrimitives      EventPrimitives-*      Event
+use GeoPrimitives        GeoPrimitives-*        DetectorDescription
+
+library xAODEgamma ../Root/*.cxx
+apply_pattern installed_library
+
+private
+
+use AtlasReflex   AtlasReflex-*   External
+
+apply_pattern lcgdict dict=xAODEgamma selectionfile=selection.xml \
+                      headerfiles="../xAODEgamma/xAODEgammaDict.h" \
+                      extralibfiles=../Root/dict/*.cxx