Skip to content
Snippets Groups Projects
Commit 1e7da824 authored by R D Schaffer's avatar R D Schaffer Committed by Graeme Stewart
Browse files

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

parent 19da96b4
No related branches found
No related tags found
No related merge requests found
Showing
with 1419 additions and 0 deletions
/*
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
// 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
/*
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
/*
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
/*
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);
}
/*
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
// 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
/*
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
/*
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
/*
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
/*
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));
}
/*
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
// 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
/*
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
/*
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
/*
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
/*
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);
}
/*
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 );
# 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
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
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment