Commit ae472bc3 authored by Christos Anastopoulos's avatar Christos Anastopoulos Committed by Graeme Stewart
Browse files

Add getTrackParticlesVec helper. (xAODEgamma-00-01-40)

	* Add getTrackParticlesVec helper.
	* Apparently the getTrackParticles which is there to
	* help with the isolation  and thus returns a set,
	* has led to a "confusion" as the set does not retain the original
	* ordering. The current helper has to stay as it used by the isolation.
	* Added another one that returns a vector and hopefully people will
	* either use the methods from the interface or read the comments on the methods.
	* Tagged as xAODEgamma-00-01-40

2015-06-06 Christos Anastopoulos <Christos.Anastopoulos@cern.ch>

	* Small fixes , a bit more comments, documentation
	* Tagged as xAODEgamma-00-01-39

2015-06-02 Will Buttinger <will@cern.ch>
	* Root/xAODEgammaCLIDs.cxx: Add this file to ensure the storegate+class_def stuff is encountered at compile time ... necessary
	to avoid problems with address remappings etc (need to know the SG::BASE structure early!)
	* Tagged as xAODEgamma-00-01-38

...
(Long ChangeLog diff - truncated)
parent 5afd9d74
......@@ -2,7 +2,7 @@
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: EgammaAccessors_v1.cxx 630766 2014-11-25 00:34:26Z christos $
// $Id: EgammaAccessors_v1.cxx 667007 2015-05-13 18:57:07Z christos $
// System include(s):
#include <iostream>
......@@ -70,11 +70,6 @@ namespace xAOD {
DEFINE_ACCESSOR( float, Rhad );
DEFINE_ACCESSOR( float, Rhad1 );
DEFINE_ACCESSOR( float, DeltaE );
DEFINE_ACCESSOR( float, zvertex );
DEFINE_ACCESSOR( float, errz );
DEFINE_ACCESSOR( float, etap );
DEFINE_ACCESSOR( float, depth );
default:
std::cerr << "xAOD::Egamma ERROR Unknown float ShowerShapeType ("
<< type << ") requested" << std::endl;
......
......@@ -8,29 +8,11 @@
#include "xAODEgamma/Electron.h"
#include "xAODTruth/TruthVertex.h"
#include "xAODTruth/TruthParticle.h"
#include "xAODTruth/xAODTruthHelpers.h"
#include "xAODTruth/TruthParticleContainer.h"
#include "xAODEgamma/ElectronContainer.h"
#include "xAODEgamma/PhotonContainer.h"
// ==================================================================
const xAOD::TruthParticle* xAOD::EgammaHelpers::getTruthParticle(const xAOD::IParticle* particle){
return getLink<xAOD::TruthParticle>(particle, "truthParticleLink");
}
int xAOD::EgammaHelpers::getParticleTruthType(const xAOD::IParticle* particle){
static SG::AuxElement::Accessor<int> tT("truthType") ;
if (!tT.isAvailable(*particle)) return 0;
return tT(*particle);
}
int xAOD::EgammaHelpers::getParticleTruthOrigin(const xAOD::IParticle* particle){
static SG::AuxElement::Accessor<int> tO("truthOrigin") ;
if (!tO.isAvailable(*particle)) return 0;
return tO(*particle);
}
// ==================================================================
const xAOD::Electron* xAOD::EgammaHelpers::getRecoElectron(const xAOD::TruthParticle* particle){
......@@ -40,20 +22,18 @@ const xAOD::Electron* xAOD::EgammaHelpers::getRecoElectron(const xAOD::TruthPart
const xAOD::Photon* xAOD::EgammaHelpers::getRecoPhoton(const xAOD::TruthParticle* particle){
return getLink<xAOD::Photon>(particle, "recoPhotonLink");
}
// ==================================================================
//Is the object matched to a true converted photon with R < maxRadius
bool xAOD::EgammaHelpers::isTrueConvertedPhoton(const xAOD::Photon* ph, float maxRadius /* = 800. */){
const xAOD::TruthParticle *truthPh = xAOD::EgammaHelpers::getTruthParticle(ph);
const xAOD::TruthParticle *truthPh = xAOD::TruthHelpers::getTruthParticle(*ph);
if (!truthPh) {return false;}
// In older versions egammaTruthParticles did not have a decay vertex associated
// so we look for the original truth particle
if (truthPh->hasDecayVtx()){
return isTrueConvertedPhoton(truthPh, maxRadius);
}
const xAOD::TruthParticle *orgTruthPh = xAOD::EgammaHelpers::getTruthParticle(truthPh);
const xAOD::TruthParticle *orgTruthPh = xAOD::TruthHelpers::getTruthParticle(*truthPh);
if (!orgTruthPh){ return false;}
return xAOD::EgammaHelpers::isTrueConvertedPhoton(orgTruthPh, maxRadius);
}
......@@ -65,34 +45,37 @@ bool xAOD::EgammaHelpers::isTrueConvertedPhoton(const xAOD::TruthParticle* truth
}
// ==================================================================
const xAOD::TruthParticle* xAOD::EgammaHelpers::getMotherElectron(const xAOD::Electron* el){
const xAOD::TruthParticle *truthel = xAOD::EgammaHelpers::getTruthParticle(el);
return getMotherElectron(truthel);
const xAOD::TruthParticle* xAOD::EgammaHelpers::getBkgElectronMother(const xAOD::Electron* el){
const xAOD::TruthParticle *truthel = xAOD::TruthHelpers::getTruthParticle(*el);
return getBkgElectronMother(truthel);
}
const xAOD::TruthParticle* xAOD::EgammaHelpers::getMotherElectron(const xAOD::TruthParticle* truthel){
if (!truthel || truthel->absPdgId()!=11){ //Truth must exist and be an electron
const xAOD::TruthParticle* xAOD::EgammaHelpers::getBkgElectronMother(const xAOD::TruthParticle* truthel){
//Truth must exist and be an electron
if (!truthel || truthel->absPdgId()!=11){
return 0;
}
for (size_t i =0;i < truthel->nParents();++i){ //Loop over the truth electron parents
const xAOD::TruthParticle *elparent = truthel->parent(i);
if(elparent->absPdgId() ==11){ //e->gamma+e case
return elparent;
///
// The first parent has to exist
if (!truthel->nParents()){
return 0;
}
//And has to be a photon or electron
const xAOD::TruthParticle* parent = truthel->parent();
if(parent->absPdgId() !=22 && parent->absPdgId() !=11){
return 0;
}
while (parent->nParents()){ //Loop over the generations
const xAOD::TruthParticle* tmp = parent->parent();
//You want to see an electron or a photon
if(tmp->absPdgId() ==22 || tmp->absPdgId() ==11){
parent=tmp;
}
else if(elparent->pdgId() ==22) { //Photon parent, lets check if it comes from an electron
//Loop over the truth photon parents (electron grandparents)
for (size_t j =0 ;j<elparent->nParents();++j){
const xAOD::TruthParticle *elgrandparent = elparent->parent(j);
if(elgrandparent->absPdgId() ==11){ //Photon comes from an electron
return elgrandparent;
}
}//Loop over grandparents
} // Parent is Photon
}//Loop over parents
return 0;
else{ // if we do not see any more electron and photons we stop
break ;
}
}
return parent;
}
// ==================================================================
......@@ -149,9 +149,7 @@ namespace xAOD {
static Accessor< uint16_t > acc( "author" );
acc( *this) = newAuthor;
}
/////////////// shower shapes
bool Egamma_v1::showerShapeValue(float& value, const EgammaParameters::ShowerShapeType information) const {
xAOD::Egamma_v1::Accessor< float >* acc = showerShapeAccessorV1( information );
......@@ -182,7 +180,7 @@ namespace xAOD {
}
/////////////// Isolation value
bool Egamma_v1::isolationValue(float& value, const Iso::IsolationType information) const {
bool Egamma_v1::isolation(float& value, const Iso::IsolationType information) const {
SG::AuxElement::Accessor< float >* acc = getIsolationAccessor( information );
if( !acc ) {
return false;
......@@ -195,13 +193,13 @@ namespace xAOD {
return true;
}
float Egamma_v1::isolationValue( const Iso::IsolationType information) const {
float Egamma_v1::isolation( const Iso::IsolationType information) const {
SG::AuxElement::Accessor< float >* acc = getIsolationAccessor( information );
if( !acc ) throw std::runtime_error( "Unknown/Unavailable Isolation type requested" );
return ( *acc )( *this );
}
bool Egamma_v1::setIsolationValue(float value, const Iso::IsolationType information) {
bool Egamma_v1::setIsolation(float value, const Iso::IsolationType information) {
SG::AuxElement::Accessor< float >* acc = getIsolationAccessor( information );
if( !acc ) return false;
// Set the value:
......@@ -262,7 +260,6 @@ namespace xAOD {
return ( *acc )( *this );
}
bool Egamma_v1::setIsolationCaloCorrection(float value, Iso::IsolationType type, Iso::IsolationCaloCorrection corr){
SG::AuxElement::Accessor< float >* acc = getIsolationCorrectionAccessor(type,corr);
if( !acc ) return false;
......@@ -271,7 +268,6 @@ namespace xAOD {
return true;
}
bool Egamma_v1::isolationTrackCorrection(float& value, const Iso::IsolationFlavour flavour, const Iso::IsolationTrackCorrection corr) const{
SG::AuxElement::Accessor< float >* acc = getIsolationCorrectionAccessor(flavour,corr);
if( !acc ) {
......@@ -300,7 +296,7 @@ namespace xAOD {
return true;
}
bool Egamma_v1::isolationCorrectionBitset(uint32_t& value, const Iso::IsolationFlavour flavour ) const{
bool Egamma_v1::isolationCorrectionBitset( std::bitset<32>& value, const Iso::IsolationFlavour flavour ) const{
SG::AuxElement::Accessor< uint32_t >* acc = getIsolationCorrectionBitsetAccessor( flavour );
if( !acc ) {
return false;
......@@ -309,14 +305,14 @@ namespace xAOD {
return false;
}
// Retrieve the value:
value = ( *acc )( *this );
value = std::bitset<32>(( *acc )( *this ));
return true;
}
uint32_t Egamma_v1::isolationCorrectionBitset(const Iso::IsolationFlavour flavour ) const{
std::bitset<32> Egamma_v1::isolationCorrectionBitset(const Iso::IsolationFlavour flavour ) const{
SG::AuxElement::Accessor< uint32_t >* acc = getIsolationCorrectionBitsetAccessor( flavour );
if( !acc ) throw std::runtime_error( "Unknown/Unavailable Isolation BitSet requested" );
return ( *acc )( *this );
return std::bitset<32>(( *acc )( *this ));
}
bool Egamma_v1::setIsolationCorrectionBitset(uint32_t value, const Iso::IsolationFlavour flavour ) {
......@@ -327,8 +323,6 @@ namespace xAOD {
return true;
}
////////////////////////////////////////////////////
/// Implementation of the CaloCluster accessor functions
size_t Egamma_v1::nCaloClusters() const {
......@@ -414,7 +408,6 @@ namespace xAOD {
return;
}
bool Egamma_v1::selectionisEM(unsigned int& value, const xAOD::EgammaParameters::SelectionisEM isEM) const {
SG::AuxElement::Accessor< unsigned int >* acc = selectionisEMAccessorV1( isEM );
if(!acc ) {
......@@ -438,8 +431,8 @@ namespace xAOD {
( *acc )( *this )=value;
return;
}
///Then with strings (full flexibility)
/////////////////////////////////////////////////////////////////////////
///Then with strings (full flexibility when adding new menus dynamically)
bool Egamma_v1::passSelection(bool& value, const std::string& menu ) const {
SG::AuxElement::Accessor< char > acc( menu );
if(!acc.isAvailable( *this) ) {
......
......@@ -9,65 +9,84 @@
#include "xAODCaloEvent/CaloCluster.h"
#include "xAODTracking/TrackParticle.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) );
}
// ==================================================================
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*>();
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);
}
return std::set<const xAOD::TrackParticle*>();
}
// ==================================================================
const std::vector<const xAOD::TrackParticle*> xAOD::EgammaHelpers::getTrackParticlesVec(const xAOD::Egamma *eg,
bool useBremAssoc /* = true */,
bool allParticles /* = true */){
if (!eg) {
return std::vector<const xAOD::TrackParticle*>();
}
if (eg->type()==xAOD::Type::Electron) {
const xAOD::Electron* el = static_cast<const xAOD::Electron*> (eg);
if (el) return getTrackParticlesVec(el, useBremAssoc, allParticles);
}
if (eg->type()==xAOD::Type::Photon) {
const xAOD::Photon* ph = static_cast<const xAOD::Photon*> (eg);
if (ph) return getTrackParticlesVec(ph, useBremAssoc);
}
return std::vector<const xAOD::TrackParticle*>();
}
int xAOD::EgammaHelpers::summaryValueInt(const xAOD::TrackParticle& tp, const xAOD::SummaryType& info, int deflt /* = -999 */){
// ==================================================================
int xAOD::EgammaHelpers::summaryValueInt(const xAOD::TrackParticle& tp,
const xAOD::SummaryType& info,
int deflt /* = -999 */){
uint8_t dummy(0);
return (tp.summaryValue(dummy, info) ? dummy : deflt);
}
float xAOD::EgammaHelpers::summaryValueFloat(const xAOD::TrackParticle& tp, const xAOD::SummaryType& info, int deflt /* = -999. */){
// ==================================================================
float xAOD::EgammaHelpers::summaryValueFloat(const xAOD::TrackParticle& tp,
const xAOD::SummaryType& info,
int deflt /* = -999. */){
float dummy(0);
return (tp.summaryValue(dummy, info) ? dummy : deflt);
}
......@@ -15,7 +15,6 @@
namespace xAOD {
Electron_v1::Electron_v1() : Egamma_v1() {
}
Electron_v1::Electron_v1(const Electron_v1& el) : Egamma_v1(el){
......@@ -34,7 +33,6 @@ namespace xAOD {
AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( Electron_v1, float, charge, setCharge )
Type::ObjectType Electron_v1::type() const {
return Type::Electron;
}
......@@ -114,7 +112,6 @@ namespace xAOD {
return true;
}
bool Electron_v1::trackParticleSummaryValue( uint8_t& value, const SummaryType information, int index ) const {
const xAOD::TrackParticle* tempTrackParticle = trackParticle(index);
......@@ -128,7 +125,6 @@ namespace xAOD {
if (!tempTrackParticle) return false;
return tempTrackParticle->summaryValue(value,information);
}
uint8_t Electron_v1::trackParticleSummaryIntValue( const SummaryType information, int index) const {
const xAOD::TrackParticle* tempTrackParticle = trackParticle(index);
......@@ -153,8 +149,7 @@ namespace xAOD {
}
return value;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
} // namespace xAOD
......@@ -8,7 +8,6 @@
#include "xAODTracking/TrackParticleContainer.h"
// ==================================================================
const xAOD::TrackParticle* xAOD::EgammaHelpers::getOriginalTrackParticle(const xAOD::Electron* el){
if(el){
......@@ -19,7 +18,7 @@ const xAOD::TrackParticle* xAOD::EgammaHelpers::getOriginalTrackParticle(const x
}
return 0;
}
// ==================================================================
const xAOD::TrackParticle* xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(const xAOD::TrackParticle* trkPar){
if(! trkPar) {return 0;}
......@@ -29,9 +28,7 @@ const xAOD::TrackParticle* xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(
return (*orig(*trkPar));
}
// ==================================================================
float xAOD::EgammaHelpers::getLastMeasurementQoverP(const xAOD::TrackParticle *tp){
static SG::AuxElement::Accessor<float > QoverPLM ("QoverPLM");
......@@ -40,12 +37,10 @@ float xAOD::EgammaHelpers::getLastMeasurementQoverP(const xAOD::TrackParticle *t
}
return -999 ;
}
// ==================================================================
const std::set<const xAOD::TrackParticle*> xAOD::EgammaHelpers::getTrackParticles(const xAOD::Electron* el,
bool useBremAssoc /* = true */, bool allParticles /* = true */){
bool useBremAssoc /* = true */,
bool allParticles /* = true */){
std::set<const xAOD::TrackParticle*> tps;
for (unsigned int i = 0; i < el->nTrackParticles(); ++i){
......@@ -56,12 +51,24 @@ const std::set<const xAOD::TrackParticle*> xAOD::EgammaHelpers::getTrackParticle
}
return tps;
}
// ==================================================================
const std::vector<const xAOD::TrackParticle*> xAOD::EgammaHelpers::getTrackParticlesVec(const xAOD::Electron* el,
bool useBremAssoc /* = true */,
bool allParticles /* = true */){
std::vector<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.push_back( tp );}
if (!allParticles) {break;} // break after first particle
}
return tps;
}
// ==================================================================
std::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;
......
......@@ -2,7 +2,7 @@
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: Photon_v1.cxx 619818 2014-10-03 12:34:09Z christos $
// $Id: Photon_v1.cxx 667341 2015-05-15 14:39:34Z christos $
// EDM include(s):
#include "xAODCore/AuxStoreAccessorMacros.h"
......@@ -33,7 +33,6 @@ namespace xAOD {
return *this;
}
Type::ObjectType Photon_v1::type() const {
return Type::Photon;
......
......@@ -35,11 +35,14 @@ xAOD::EgammaParameters::ConversionType xAOD::EgammaHelpers::conversionType(const
{return nSiHits1 ? xAOD::EgammaParameters::singleSi : xAOD::EgammaParameters::singleTRT;}
if (nSiHits1 && nSiHits2){
return xAOD::EgammaParameters::doubleSi;}
return xAOD::EgammaParameters::doubleSi;
}
else if (nSiHits1 || nSiHits2){
return xAOD::EgammaParameters::doubleSiTRT;}
return xAOD::EgammaParameters::doubleSiTRT;
}
else{
return xAOD::EgammaParameters::doubleTRT;}
return xAOD::EgammaParameters::doubleTRT;
}
}
// ==================================================================
......@@ -102,17 +105,27 @@ Amg::Vector3D xAOD::EgammaHelpers::momentumAtVertex(const xAOD::Vertex& vertex,
}
// ==================================================================
const std::set<const xAOD::TrackParticle*> xAOD::EgammaHelpers::getTrackParticles(const xAOD::Photon* ph,
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)
{
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 std::vector<const xAOD::TrackParticle*> xAOD::EgammaHelpers::getTrackParticlesVec(const xAOD::Photon* ph,
bool useBremAssoc /* = true */){
std::vector<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.push_back( useBremAssoc ? xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(tp) : tp );
}
return tps;
}
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
//simple includes to force the CLASS_DEF etc to be encountered during compile
#include "xAODEgamma/EgammaContainer.h"
#include "xAODEgamma/ElectronContainer.h"
#include "xAODEgamma/ElectronAuxContainer.h"
#include "xAODEgamma/ElectronContainerFwd.h"
#include "xAODEgamma/PhotonContainer.h"
#include "xAODEgamma/PhotonAuxContainer.h"
#include "xAODEgamma/PhotonContainerFwd.h"
......@@ -42,3 +42,6 @@ use AtlasReflex AtlasReflex-* External
apply_pattern lcgdict dict=xAODEgamma selectionfile=selection.xml \
headerfiles="../xAODEgamma/xAODEgammaDict.h" \
extralibfiles=../Root/dict/*.cxx
apply_pattern do_genCLIDDB library=xAODEgamma
\ No newline at end of file
......@@ -11,8 +11,8 @@
@author Anthony Morley <Anthony.Morley@cern.ch>
@author Bruno Lenzi <Bruno.Lenzi@cern.ch>
$Revision: 636327 $
$Date: 2014-12-16 17:34:24 +0100 (Tue, 16 Dec 2014) $
$Revision: 672987 $
$Date: 2015-06-06 18:15:13 +0200 (Sat, 06 Jun 2015) $
@section xAODEgammaOverivew Overview
......@@ -52,13 +52,22 @@
and CP tools. Users should request additions in case of need.
The functions are split in 3 files:
EgammaxAODHelpers, ElectronxAODHelpers, PhotonxAODHelpers, EgammaTruthxAODHelpers
but the users only need:
<code> #include "xAODEgamma/EgammaxAODHelpers.h" </code>
- EgammaxAODHelpers
- ElectronxAODHelpers
- PhotonxAODHelpers
- EgammaTruthxAODHelpers
They are all under this namespace
- xAOD::EgammaHelpers
Including this:
<code> #include "xAODEgamma/EgammaxAODHelpers.h" </code>
makes all of them available
@section EgammaParameters Parameters
The Egamma parameters are under this namespace:
xAOD::EgammaParameters
@htmlinclude used_packages.html
@include requirements
......
......@@ -4,7 +4,7 @@
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: EgammaContainer.h 632191 2014-11-29 16:24:08Z christos $
// $Id: EgammaContainer.h 672987 2015-06-06 16:15:13Z christos $
#ifndef XAODEGAMMA_EGAMMACONTAINER_H
#define XAODEGAMMA_EGAMMACONTAINER_H
......@@ -18,9 +18,7 @@ namespace xAOD {
}