xAODMaker::ElectronCnvTool Class Reference

Implementation for the tool creating ElectronContainer from an AOD. More...

#include <ElectronCnvTool.h>

Inheritance diagram for xAODMaker::ElectronCnvTool:

Collaboration diagram for xAODMaker::ElectronCnvTool:

Public Member Functions
	ElectronCnvTool (const std::string &type, const std::string &name, const IInterface *parent)
	Regular AlgTool constructor.
virtual StatusCode	convert (const egammaContainer *aod, xAOD::ElectronContainer *xaod) const override
	Function that fills an existing xAOD::ElectronContainer (xaod or xaodForward can be NULL)
virtual StatusCode	convert (const egammaContainer *aod, xAOD::ElectronContainer *xaod, xAOD::ElectronContainer *xaodFrwd) const override
	Function that fills an existing xAOD::ElectronContainer (xaod or xaodForward can be NULL)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Gaudi interface definition.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	setParameters (const egamma &, xAOD::Electron &) const
	Fills in the shower shape variables.
void	checkAndSetParameter (egammaParameters::ParamDef aodParameter, xAOD::EgammaParameters::ShowerShapeType xaodParameter, const egamma &, xAOD::Electron &) const
void	setIsolations (const egamma &aodmuon, xAOD::Electron &xaodmuon) const
	Fills in the isolation variables.
void	checkAndSetIsolation (egammaParameters::ParamDef aodParameter, xAOD::Iso::IsolationType xaodParameter, const egamma &, xAOD::Electron &) const
void	setTrackMatch (const egamma &aodmuon, xAOD::Electron &xaodmuon) const
	Fills in the track match variables.
void	checkAndSetTrackMatch (egammaParameters::ParamDef aodParameter, xAOD::EgammaParameters::TrackCaloMatchType xaodParameter, const egamma &, xAOD::Electron &) const
void	setLinks (const egamma &, xAOD::Electron &) const
	Set the element links between the various particles.
ElementLink< xAOD::TrackParticleContainer >	getNewLink (const ElementLink< Rec::TrackParticleContainer > &oldLink, const std::string &name) const
void	setDerivedParameters (xAOD::Electron &) const
	Fills in some extra derived shower shape variables.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::string	m_inDetTrackParticlesGSF
	Other Keys.
std::string	m_inDetTrackParticles
	Location/Key for xAOD::TrackParticles from ID.
std::string	m_caloClusters
	Location/Key for xAOD::CaloClusters for electrons and photons.
std::string	m_caloClustersSofte
	Location/Key for xAOD::CaloClusters for softe electrons.
std::string	m_caloClustersFrwd
	Location/Key for xAOD::CaloClusters for forward electrons.
std::string	m_caloClustersOther
	Location/Key for xAOD::CaloClusters for other (trigger?) electrons.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Implementation for the tool creating ElectronContainer from an AOD.

   This interface is implemented by the tool that converts the
   egamma (Electron) Container into an xAOD::ElectronContainer.

Author

Jovan Mitrevski Jovan.nosp@m..Mit.nosp@m.revsk.nosp@m.i@ce.nosp@m.rn.ch

Definition at line 34 of file ElectronCnvTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

ElectronCnvTool()

xAODMaker::ElectronCnvTool::ElectronCnvTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Regular AlgTool constructor.

Definition at line 24 of file ElectronCnvTool.cxx.

    : AthAlgTool( type, name, parent )
  {
    // Declare the interface(s) provided by the tool:
    declareInterface< IElectronCnvTool >(this);
 
    declareProperty( "xAODElectronTrackContainerName", m_inDetTrackParticlesGSF = "GSFTrackParticles" );
    declareProperty( "xAODElectronOrigTrackContainerName", m_inDetTrackParticles = "InDetTrackParticles" );
    declareProperty( "xAODCaloClusterContainerName", m_caloClusters = "egClusterCollection");
    declareProperty( "xAODCaloClusterSofteContainerName", m_caloClustersSofte = "LArClusterEMSofte");
    declareProperty( "xAODCaloClusterFrwdContainerName", m_caloClustersFrwd = "LArClusterEMFrwd");
    declareProperty( "xAODCaloClusterOtherContainerName", m_caloClustersOther = "egClusterCollection", 
             "Most likely used for trigger objects");
 
  }

Member Function Documentation

checkAndSetIsolation()

void xAODMaker::ElectronCnvTool::checkAndSetIsolation ( egammaParameters::ParamDef aodParameter, xAOD::Iso::IsolationType xaodParameter, const egamma & aodel, xAOD::Electron & xaodel ) const

private

Definition at line 209 of file ElectronCnvTool.cxx.

                                                                         {
    double result = aodel.detailValue(aodParameter);
    float isolation = static_cast<float>(result);
    xaodel.setIsolationValue(isolation, xaodParameter);
  }

checkAndSetParameter()

void xAODMaker::ElectronCnvTool::checkAndSetParameter ( egammaParameters::ParamDef aodParameter, xAOD::EgammaParameters::ShowerShapeType xaodParameter, const egamma & aodel, xAOD::Electron & xaodel ) const

private

Definition at line 190 of file ElectronCnvTool.cxx.

                                                                         {
    double result = aodel.detailValue(aodParameter);
    float parameter = static_cast<float>(result);
    xaodel.setShowerShapeValue(parameter, xaodParameter);
  }

checkAndSetTrackMatch()

void xAODMaker::ElectronCnvTool::checkAndSetTrackMatch ( egammaParameters::ParamDef aodParameter, xAOD::EgammaParameters::TrackCaloMatchType xaodParameter, const egamma & aodel, xAOD::Electron & xaodel ) const

private

Definition at line 232 of file ElectronCnvTool.cxx.

                                                                          {
    double result = aodel.detailValue(aodParameter);
    float isolation = static_cast<float>(result);
    xaodel.setTrackCaloMatchValue(isolation, xaodParameter);
  }

convert() [1/2]

StatusCode xAODMaker::ElectronCnvTool::convert ( const egammaContainer * aod, xAOD::ElectronContainer * xaod ) const

overridevirtual

Function that fills an existing xAOD::ElectronContainer (xaod or xaodForward can be NULL)

Implements xAODMaker::IElectronCnvTool.

Definition at line 42 of file ElectronCnvTool.cxx.

  {
      if (!aod) { 
          ATH_MSG_WARNING("No input Electron Collection passed"); 
          return StatusCode::SUCCESS; 
      } 
      //Create the container for forward electrons
      xAOD::ElectronContainer xaodFrwd;
     
      return convert(aod,xaod,&xaodFrwd);
  }

convert() [2/2]

StatusCode xAODMaker::ElectronCnvTool::convert ( const egammaContainer * aod, xAOD::ElectronContainer * xaod, xAOD::ElectronContainer * xaodFrwd ) const

overridevirtual

Function that fills an existing xAOD::ElectronContainer (xaod or xaodForward can be NULL)

Implements xAODMaker::IElectronCnvTool.

Definition at line 55 of file ElectronCnvTool.cxx.

  {  
    if (!aod) { 
      ATH_MSG_WARNING("No input Electron Collection passed"); 
      return StatusCode::SUCCESS; 
    } 
 
    // Create the xAOD objects:
    for(const egamma* eg : *aod) {
 
      // ATH_MSG_DEBUG("Electron author = " << eg->author() 
      //            << ", container = " << eg->clusterElementLink().proxy()->name());
 
      //special treatment for forward electrons     
      if(eg->author(egammaParameters::AuthorFrwd)) {
    if (xaodFrwd) {
      xAOD::Electron* electron = new xAOD::Electron();
      xaodFrwd->push_back( electron );
      // p4
      electron->setPtEtaPhi(eg->pt(),eg->eta(),eg->phi());
      // author(s)
      electron->setAuthor( eg->author() );
      //OQ
      electron->setOQ( eg->isgoodoq() );
      //set Links
      setLinks(*eg,*electron);
    } else {
      ATH_MSG_WARNING("Found a foward electron, but xaodFrwd == NULL");
    }
      }//end if forward electron
      else{
    if (xaod) {
      xAOD::Electron* electron = new xAOD::Electron();
      // Create the xAOD object:
      xaod->push_back( electron );
      // p4
          if (eg->trackParticle()) {
            double clE = eg->cluster()->e();
            double pt  =  sqrt(clE*clE - ParticleConstants::electronMassInMeV*ParticleConstants::electronMassInMeV)/cosh(eg->trackParticle()->eta());
            double eta = eg->trackParticle()->eta();
            double phi = eg->trackParticle()->phi();
            electron->setPtEtaPhi(pt, eta, phi);
          }
          else
            electron->setPtEtaPhi(eg->pt(),eg->eta(),eg->phi());
 
      // author(s)
      electron->setAuthor( eg->author() );
      //OQ
      electron->setOQ( eg->isgoodoq() );
      // charge
      electron->setCharge( eg->charge() );
      
      // Error Matrix
      if(eg->errors()){
        
        const ErrorMatrixEEtaPhiM* oldMatrix = eg->errors()->eEtaPhiMMatrix();
        if(oldMatrix){
          Eigen::Matrix<double,4,4> matrix;
          for(int i(0);i<4;++i){
        for(int j(0);j<4;++j){
          matrix(i,j) = (*oldMatrix)(i,j);
        } 
          }
          Eigen::Matrix<double,4,4> jacobian (EigenP4JacobianEEtaPhiM2PtEtaPhiM(eg->e(),eg->eta(), eg->m()));
          Eigen::Matrix<double,4,4> covMatrix= jacobian*matrix*jacobian.transpose();
          electron->setCovMatrix(covMatrix.cast<float>());
        }
      }
      
      //setParameters
      setParameters(*eg,*electron);
      //setIsolations
      setIsolations(*eg,*electron);
      //setTrackMatch
      setTrackMatch(*eg,*electron);    
      // set Links
      setLinks(*eg,*electron); 
      // set derived parameters - should be done last
      setDerivedParameters(*electron);
  
    } else {
      ATH_MSG_WARNING("Found a regular electron, but xaod == NULL");
    }
      
      }//end If not forward
    }
    // Return gracefully:
    return StatusCode::SUCCESS;
  }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getNewLink()

ElementLink< xAOD::TrackParticleContainer > xAODMaker::ElectronCnvTool::getNewLink ( const ElementLink< Rec::TrackParticleContainer > & oldLink, const std::string & name ) const

private

Definition at line 298 of file ElectronCnvTool.cxx.

                                                                   {
    ElementLink<xAOD::TrackParticleContainer> newLink;
    std::string linkname = name;
    // If not set, use same name as in original link.
    if (linkname.empty())
      linkname = oldLink.dataID();
    newLink.resetWithKeyAndIndex( linkname, oldLink.index() );
    return newLink;
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & xAODMaker::IElectronCnvTool::interfaceID ( )

inlinestaticinherited

Gaudi interface definition.

Definition at line 49 of file IElectronCnvTool.h.

                                             {
       return IID_IElectronCnvTool;
     }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setDerivedParameters()

void xAODMaker::ElectronCnvTool::setDerivedParameters ( xAOD::Electron & xaodel ) const

private

Fills in some extra derived shower shape variables.

e237/e277

e233/e237

(emaxs1-e2tsts1)/(emaxs1+e2tsts1)

e2tsts1-emins1

ethad/et

ethad1/et

Definition at line 309 of file ElectronCnvTool.cxx.

                                                                      {
 
    // Set some extra derived variables:
    float e237 = 0;
    float e277 = 0;
    if (xaodel.showerShapeValue(e237, xAOD::EgammaParameters::e237) &&
    xaodel.showerShapeValue(e277, xAOD::EgammaParameters::e277)) {
      float reta = (e277 != 0) ? e237/e277 : 0;
      xaodel.setShowerShapeValue(reta, xAOD::EgammaParameters::Reta);
    }
    float e233 = 0;
    if (xaodel.showerShapeValue(e233, xAOD::EgammaParameters::e233)) {
      float rphi = (e237 != 0) ? e233/e237 : 0;
      xaodel.setShowerShapeValue(rphi, xAOD::EgammaParameters::Rphi);
     }
    // Eratio
    float emaxs1   = 0;
    float e2tsts1  = 0;
    if (xaodel.showerShapeValue(emaxs1, xAOD::EgammaParameters::emaxs1) &&
    xaodel.showerShapeValue(e2tsts1, xAOD::EgammaParameters::e2tsts1)) {
         float dEmaxs1  = 0;
         float esums1 = emaxs1 + e2tsts1;
         if (fabs(esums1) > 0.0) dEmaxs1   = (emaxs1 - e2tsts1)/esums1;
         xaodel.setShowerShapeValue(dEmaxs1, xAOD::EgammaParameters::Eratio);
    }
    
    float emins1   = 0;
    if (xaodel.showerShapeValue(emins1, xAOD::EgammaParameters::emins1)) {
      float deltaE   = e2tsts1 - emins1;
      xaodel.setShowerShapeValue(deltaE, xAOD::EgammaParameters::DeltaE);
     }
    
    const xAOD::CaloCluster*   el_cl = xaodel.caloCluster();
    if(el_cl != nullptr) {
      float elEta    = fabs(el_cl->etaBE(2));
      float elEt     = el_cl->e()/cosh(elEta);
      float ethad    = 0;
      if (xaodel.showerShapeValue(ethad, xAOD::EgammaParameters::ethad)) {
    float raphad = fabs(elEt) != 0. ? ethad/elEt : 0.;
    xaodel.setShowerShapeValue(raphad, xAOD::EgammaParameters::Rhad);
      }
      
      float ethad1   = 0;
      if (xaodel.showerShapeValue(ethad1, xAOD::EgammaParameters::ethad1)) {
    float raphad1    = fabs(elEt) != 0. ? ethad1/elEt : 0.;
    xaodel.setShowerShapeValue(raphad1, xAOD::EgammaParameters::Rhad1);
      }
    } else {
      ATH_MSG_WARNING("No xAOD::CaloCluster was found during the conversion egammaContainer -> xAOD::ElectronContainer");
    }
  }

setIsolations()

void xAODMaker::ElectronCnvTool::setIsolations ( const egamma & aodmuon, xAOD::Electron & xaodmuon ) const

private

Fills in the isolation variables.

Definition at line 198 of file ElectronCnvTool.cxx.

                                                                                     {
    checkAndSetIsolation(egammaParameters::etcone20     ,   xAOD::Iso::etcone20     ,  aodel,   xaodel);
    checkAndSetIsolation(egammaParameters::etcone30     ,   xAOD::Iso::etcone30     ,  aodel,   xaodel);
    checkAndSetIsolation(egammaParameters::etcone40     ,   xAOD::Iso::etcone40     ,  aodel,   xaodel);
    checkAndSetIsolation(egammaParameters::ptcone30     ,   xAOD::Iso::ptcone30     ,  aodel,   xaodel);
    checkAndSetIsolation(egammaParameters::ptcone40     ,   xAOD::Iso::ptcone40     ,  aodel,   xaodel);   
    checkAndSetIsolation(egammaParameters::topoetcone20     ,   xAOD::Iso::topoetcone20     ,  aodel,   xaodel);  
    checkAndSetIsolation(egammaParameters::topoetcone30     ,   xAOD::Iso::topoetcone30     ,  aodel,   xaodel);  
    checkAndSetIsolation(egammaParameters::topoetcone40     ,   xAOD::Iso::topoetcone40     ,  aodel,   xaodel); 
  }

setLinks()

void xAODMaker::ElectronCnvTool::setLinks ( const egamma & aodel, xAOD::Electron & xaodel ) const

private

Set the element links between the various particles.

Definition at line 242 of file ElectronCnvTool.cxx.

  {
    std::string clusterContainerName;
 
    // Need to reset links from old CaloCluster to xAOD::CaloCluster
    ElementLink<xAOD::CaloClusterContainer> newclusterElementLink;
    if( aodel.author(egammaParameters::AuthorElectron) ){ 
      clusterContainerName = m_caloClusters;
 
      std::vector< ElementLink< xAOD::TrackParticleContainer > > linksToTracks;
      for(unsigned int i(0); i<aodel.nTrackParticles(); ++i){
    linksToTracks.push_back( getNewLink(aodel.trackParticleElementLink(i), m_inDetTrackParticlesGSF) );
      }
      xaodel.setTrackParticleLinks( linksToTracks );
 
    }
    else if ( aodel.author(egammaParameters::AuthorSofte) ) {
      clusterContainerName = m_caloClustersSofte;
    
      //softe do not use GSF Tracks
      std::vector< ElementLink< xAOD::TrackParticleContainer > > linksToTracks;
      for(unsigned int i(0); i<aodel.nTrackParticles(); ++i){
    linksToTracks.push_back( getNewLink(aodel.trackParticleElementLink(i), m_inDetTrackParticles) );
      }
      xaodel.setTrackParticleLinks( linksToTracks );
    
    }
    else if ( aodel.author(egammaParameters::AuthorFrwd) ) { 
      clusterContainerName = m_caloClustersFrwd;
    }
    else { // assume a trigger object
      clusterContainerName = m_caloClustersOther;
      
      // trigger does not use GSF
      std::vector< ElementLink< xAOD::TrackParticleContainer > > linksToTracks;
      for(unsigned int i(0); i<aodel.nTrackParticles(); ++i){
    linksToTracks.push_back( getNewLink(aodel.trackParticleElementLink(i), m_inDetTrackParticles) );
      }
      xaodel.setTrackParticleLinks( linksToTracks );
    }      
 
    // If EL name not set, use the original name.
    if (clusterContainerName.empty())
      clusterContainerName = aodel.clusterElementLink().dataID();
 
    newclusterElementLink.resetWithKeyAndIndex( clusterContainerName,
                                                aodel.clusterElementLink().index()  );
 
    std::vector< ElementLink< xAOD::CaloClusterContainer > > linksToClusters;
    linksToClusters.push_back(newclusterElementLink);
    xaodel.setCaloClusterLinks(linksToClusters);
    
    if (!newclusterElementLink.isValid()) ATH_MSG_WARNING("Invalid link to cluster");
    
  }

setParameters()

void xAODMaker::ElectronCnvTool::setParameters ( const egamma & aodel, xAOD::Electron & xaodel ) const

private

Fills in the shower shape variables.

Definition at line 148 of file ElectronCnvTool.cxx.

                                                                                     {
    // We're not doing all AOD parameters here because some are dropped, and some are moved elsewhere.
    checkAndSetParameter(egammaParameters::e011        ,   xAOD::EgammaParameters::e011        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e033        ,   xAOD::EgammaParameters::e033        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e132        ,   xAOD::EgammaParameters::e132        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e1152       ,   xAOD::EgammaParameters::e1152       ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::ethad       ,   xAOD::EgammaParameters::ethad       ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::ethad1      ,   xAOD::EgammaParameters::ethad1      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::ehad1       ,   xAOD::EgammaParameters::ehad1       ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::f1          ,   xAOD::EgammaParameters::f1          ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::f3          ,   xAOD::EgammaParameters::f3          ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::f1core      ,   xAOD::EgammaParameters::f1core      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::f3core      ,   xAOD::EgammaParameters::f3core      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e233        ,   xAOD::EgammaParameters::e233        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e235        ,   xAOD::EgammaParameters::e235        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e255        ,   xAOD::EgammaParameters::e255        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e237        ,   xAOD::EgammaParameters::e237        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e277        ,   xAOD::EgammaParameters::e277        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e333        ,   xAOD::EgammaParameters::e333        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e335        ,   xAOD::EgammaParameters::e335        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e337        ,   xAOD::EgammaParameters::e337        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e377        ,   xAOD::EgammaParameters::e377        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::weta1       ,   xAOD::EgammaParameters::weta1       ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::weta2       ,   xAOD::EgammaParameters::weta2       ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e2ts1       ,   xAOD::EgammaParameters::e2ts1       ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::e2tsts1     ,   xAOD::EgammaParameters::e2tsts1     ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::fracs1      ,   xAOD::EgammaParameters::fracs1      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::widths1     ,   xAOD::EgammaParameters::widths1     ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::widths2     ,   xAOD::EgammaParameters::widths2     ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::poscs1      ,   xAOD::EgammaParameters::poscs1      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::poscs2      ,   xAOD::EgammaParameters::poscs2      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::asy1        ,   xAOD::EgammaParameters::asy1        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::pos         ,   xAOD::EgammaParameters::pos         ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::pos7        ,   xAOD::EgammaParameters::pos7        ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::barys1      ,   xAOD::EgammaParameters::barys1      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::wtots1      ,   xAOD::EgammaParameters::wtots1      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::emins1      ,   xAOD::EgammaParameters::emins1      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::emaxs1      ,   xAOD::EgammaParameters::emaxs1      ,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::r33over37allcalo ,   xAOD::EgammaParameters::r33over37allcalo,  aodel,   xaodel);
    checkAndSetParameter(egammaParameters::ecore       ,   xAOD::EgammaParameters::ecore       ,  aodel,   xaodel);
  }

setTrackMatch()

void xAODMaker::ElectronCnvTool::setTrackMatch ( const egamma & aodmuon, xAOD::Electron & xaodmuon ) const

private

Fills in the track match variables.

Definition at line 218 of file ElectronCnvTool.cxx.

                                                                                     {
    checkAndSetTrackMatch(egammaParameters::deltaEta0     ,   xAOD::EgammaParameters::deltaEta0     ,  aodel,   xaodel);
    checkAndSetTrackMatch(egammaParameters::deltaEta1     ,   xAOD::EgammaParameters::deltaEta1     ,  aodel,   xaodel);
    checkAndSetTrackMatch(egammaParameters::deltaEta2     ,   xAOD::EgammaParameters::deltaEta2     ,  aodel,   xaodel);
    checkAndSetTrackMatch(egammaParameters::deltaEta3     ,   xAOD::EgammaParameters::deltaEta3     ,  aodel,   xaodel);
    checkAndSetTrackMatch(egammaParameters::deltaPhi0     ,   xAOD::EgammaParameters::deltaPhi0     ,  aodel,   xaodel);
    checkAndSetTrackMatch(egammaParameters::deltaPhi1     ,   xAOD::EgammaParameters::deltaPhi1     ,  aodel,   xaodel);
    checkAndSetTrackMatch(egammaParameters::deltaPhi2     ,   xAOD::EgammaParameters::deltaPhi2     ,  aodel,   xaodel);
    checkAndSetTrackMatch(egammaParameters::deltaPhi3     ,   xAOD::EgammaParameters::deltaPhi3     ,  aodel,   xaodel);
    checkAndSetTrackMatch(egammaParameters::deltaPhiFromLastMeasurement,   xAOD::EgammaParameters::deltaPhiFromLastMeasurement,  aodel,   xaodel);
    checkAndSetTrackMatch(egammaParameters::deltaPhiRescaled,   xAOD::EgammaParameters::deltaPhiRescaled2     ,  aodel,   xaodel);
  
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_caloClusters

std::string xAODMaker::ElectronCnvTool::m_caloClusters

private

Location/Key for xAOD::CaloClusters for electrons and photons.

Definition at line 74 of file ElectronCnvTool.h.

m_caloClustersFrwd

std::string xAODMaker::ElectronCnvTool::m_caloClustersFrwd

private

Location/Key for xAOD::CaloClusters for forward electrons.

Definition at line 76 of file ElectronCnvTool.h.

m_caloClustersOther

std::string xAODMaker::ElectronCnvTool::m_caloClustersOther

private

Location/Key for xAOD::CaloClusters for other (trigger?) electrons.

Definition at line 77 of file ElectronCnvTool.h.

m_caloClustersSofte

std::string xAODMaker::ElectronCnvTool::m_caloClustersSofte

private

Location/Key for xAOD::CaloClusters for softe electrons.

Definition at line 75 of file ElectronCnvTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_inDetTrackParticles

std::string xAODMaker::ElectronCnvTool::m_inDetTrackParticles

private

Location/Key for xAOD::TrackParticles from ID.

Definition at line 73 of file ElectronCnvTool.h.

m_inDetTrackParticlesGSF

std::string xAODMaker::ElectronCnvTool::m_inDetTrackParticlesGSF

private

Other Keys.

Location/Key for xAOD::TrackParticles from ID

Definition at line 72 of file ElectronCnvTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• ElectronCnvTool.h
• ElectronCnvTool.cxx