DerivationFramework::EGammaTracksThinning Class Reference

#include <EGammaTracksThinning.h>

Inheritance diagram for DerivationFramework::EGammaTracksThinning:

Collaboration diagram for DerivationFramework::EGammaTracksThinning:

Public Member Functions
	EGammaTracksThinning (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~EGammaTracksThinning ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	doThinning () const override

Private Member Functions
std::set< int >	findGoodTracks (const TrackCollection *trackCont, const TLorentzVector &candHepLorentz, double maxDeltaR) const
StatusCode	thinTracks (SG::ThinningHandle< TrackCollection > &trackCont, const std::set< int > &goodTracks) const

Private Attributes
StringProperty	m_streamName { this, "StreamName", "", "Name of the stream being thinned" }
SG::ReadHandleKey< xAOD::ElectronContainer >	m_electronsContainerKey { this, "electronContainerName", "Electrons", "" }
SG::ReadHandleKey< xAOD::PhotonContainer >	m_photonsContainerKey { this, "photonContainerName", "Photons", ""}
SG::ThinningHandleKey< TrackCollection >	m_tracksCollectionName { this, "tracksCollectionName", "Tracks", "" }
Gaudi::Property< double >	m_dr { this, "deltaR", 0.5, "" }
Gaudi::Property< double >	m_minEtEg { this, "minEtEg", 0,""}

Detailed Description

Definition at line 30 of file EGammaTracksThinning.h.

Constructor & Destructor Documentation

EGammaTracksThinning()

DerivationFramework::EGammaTracksThinning::EGammaTracksThinning	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 10 of file EGammaTracksThinning.cxx.

                                                                              :
  base_class(type, name, parent)
{}

~EGammaTracksThinning()

virtual DerivationFramework::EGammaTracksThinning::~EGammaTracksThinning ( )

inlinevirtual

Definition at line 38 of file EGammaTracksThinning.h.

{}

Member Function Documentation

doThinning()

StatusCode DerivationFramework::EGammaTracksThinning::doThinning ( ) const

overridevirtual

Definition at line 29 of file EGammaTracksThinning.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // retrieve the tracks collection
 
  SG::ThinningHandle<TrackCollection> trackCollection
    (m_tracksCollectionName, ctx);
  ATH_MSG_DEBUG( "Container '" << m_tracksCollectionName.key() << "' retrieved from StoreGate" );      
  
  // retrieve the electron collection
 
  SG::ReadHandle<xAOD::ElectronContainer> electronContainer(m_electronsContainerKey, ctx);
  if ( !electronContainer.isValid() )
    {
      ATH_MSG_WARNING( "Container '" << m_electronsContainerKey.key()
                       << "' could not be retrieved from StoreGate!" ); 
      return StatusCode::FAILURE;
    } 
  else
    {
      ATH_MSG_DEBUG( "Container '" << m_electronsContainerKey.key()
                     << "' retrieved from StoreGate" );
    }
 
   // retrieve the photon collection
  
  SG::ReadHandle<xAOD::PhotonContainer> photonContainer(m_photonsContainerKey,ctx);
  if ( !photonContainer.isValid() )
    {
      ATH_MSG_WARNING( "Container '" << m_photonsContainerKey.key()
                       << "' could not be retrieved from StoreGate!" ); 
      return StatusCode::FAILURE;
    } 
  else
    {
      ATH_MSG_DEBUG( "Container '" << m_photonsContainerKey.key()
                     << "' retrieved from StoreGate" );
    }
 
  // loop over electrons and for each electron mark the interesting tracks
 
  std::set<int> goodTrackIDs;
 
  xAOD::ElectronContainer::const_iterator eleItr    = electronContainer->begin();
  xAOD::ElectronContainer::const_iterator eleItrEnd = electronContainer->end();
  for (; eleItr != eleItrEnd; ++eleItr)
    {
      if ( (*eleItr)->pt() > m_minEtEg ) 
        {
          
          ATH_MSG_DEBUG(  "Electron at eta = " << (*eleItr)->eta() << " phi = " << (*eleItr)->phi() );          
          
          // get the list of tracks associated to this object
 
          std::set<int> eg_trackList =  findGoodTracks(trackCollection.cptr(), (*eleItr)->p4(), m_dr );
 
          // update the global list of tracks to keep
 
          goodTrackIDs.insert(eg_trackList.begin() , eg_trackList.end() ) ;
          
        }
      
    }
  
  // loop over photons and for each photon mark the interesting tracks
 
  xAOD::PhotonContainer::const_iterator phoItr    = photonContainer->begin();
  xAOD::PhotonContainer::const_iterator phoItrEnd = photonContainer->end();
  for (; phoItr != phoItrEnd; ++phoItr)
    {
      if ( (*phoItr)->pt() > m_minEtEg ) 
        {
          
          ATH_MSG_DEBUG(  "Photon at eta = " << (*phoItr)->eta() << " phi = " << (*phoItr)->phi() );          
          
          // get the list of tracks associated to this object
 
          std::set<int> eg_trackList =  findGoodTracks(trackCollection.cptr(), (*phoItr)->p4(), m_dr );
 
          // update the global list of tracks to keep
 
          goodTrackIDs.insert(eg_trackList.begin() , eg_trackList.end() ) ;
          
        }
      
    }
    
  // now do the real thinning and keep all marked tracks
 
  ATH_CHECK( thinTracks( trackCollection, goodTrackIDs ) );
  
  ATH_MSG_DEBUG( "Track thinning : tracks = " << trackCollection->size() 
                << " accepted = " << goodTrackIDs.size() ); 
  
  return StatusCode::SUCCESS;
}

finalize()

StatusCode DerivationFramework::EGammaTracksThinning::finalize ( )

overridevirtual

Definition at line 24 of file EGammaTracksThinning.cxx.

                                                            {
 
  return StatusCode::SUCCESS;
}

findGoodTracks()

std::set< int > DerivationFramework::EGammaTracksThinning::findGoodTracks ( const TrackCollection *  trackCont, const TLorentzVector &  candHepLorentz, double  maxDeltaR  ) const

private

Definition at line 132 of file EGammaTracksThinning.cxx.

{
 
  std::set<int> goodTracks;
 
  TrackCollection::const_iterator trackItr    = trackCont->begin();
  TrackCollection::const_iterator trackItrEnd = trackCont->end();
  long int i=0; // This is the counter...
  for (; trackItr != trackItrEnd; ++trackItr)
    {
      const Trk::Track* track = (*trackItr);
      
      if (!track){ continue; }  
 
      // use track eta/phi at perigee
 
      double trketa = 0.,trkphi = 0;
      const Trk::Perigee* startPerigee = track->perigeeParameters();
      trketa = startPerigee->eta();
      trkphi = startPerigee->parameters()[Trk::phi0];
  
      double deltaEta = trketa - candHepLorentz.Eta() ;
      double deltaPhi = P4Helpers::deltaPhi(trkphi, candHepLorentz.Phi() );
      double deltaR = sqrt(deltaEta*deltaEta+deltaPhi*deltaPhi);
    
      ATH_MSG_DEBUG( "Thin Tracks: eta = " << trketa << "  phi = " << trkphi << " deltaR = " << deltaR );            
      if ( deltaR < maxDeltaR )
        {
          goodTracks.insert( i );
          ATH_MSG_DEBUG( "  Track in the cone, adding: " << " eta=" << trketa << " phi="    << trkphi );
        } 
     
      ++i; // Increment the counter
            
    } 
  
  return goodTracks;
 
}

initialize()

StatusCode DerivationFramework::EGammaTracksThinning::initialize ( )

overridevirtual

Definition at line 16 of file EGammaTracksThinning.cxx.

                                                              {
 
  ATH_CHECK( m_electronsContainerKey.initialize() );
  ATH_CHECK( m_photonsContainerKey.initialize() );
  ATH_CHECK( m_tracksCollectionName.initialize (m_streamName) );
  return StatusCode::SUCCESS;
}

thinTracks()

StatusCode DerivationFramework::EGammaTracksThinning::thinTracks ( SG::ThinningHandle< TrackCollection > &  trackCont, const std::set< int > &  goodTracks  ) const

private

Return

Definition at line 179 of file EGammaTracksThinning.cxx.

{
  
  ATH_MSG_DEBUG( "==> thinTracks " << name() << "..." );
  
  // Declare the simple StatusCode
  StatusCode sc(StatusCode::SUCCESS);
 
  // First, create the mask to be used for thinning
  
  std::vector<bool> mask(trackCollection->size());
  
  // Create also some bookkeeping counters
  unsigned long nTotal  = 0;
  unsigned long nKeep   = 0;
  unsigned long nReject = 0;
  
  // loop over tracks
  
  for ( std::size_t i=0; i<trackCollection->size(); ++i )
    {
      ++nTotal;
      if ( goodTrackIDs.find( i ) != goodTrackIDs.end() )
        {
          mask[i] = true;
          ++nKeep;
        }
      else
        {
          mask[i] = false;
          ++nReject;
        }
    } // End loop over Tracks
 
  // Write out a statistics message
  ATH_MSG_DEBUG( " EGammaTracksThinning statistics: tracks processed " << nTotal 
                << " kept = " << nKeep
                << " rejected " << nReject );
  
  // Perform the actual thinning
  trackCollection.thin (mask);
    
  return sc;    
    
}

Member Data Documentation

m_dr

Gaudi::Property<double> DerivationFramework::EGammaTracksThinning::m_dr { this, "deltaR", 0.5, "" }

private

Definition at line 53 of file EGammaTracksThinning.h.

m_electronsContainerKey

SG::ReadHandleKey<xAOD::ElectronContainer> DerivationFramework::EGammaTracksThinning::m_electronsContainerKey { this, "electronContainerName", "Electrons", "" }

private

Definition at line 47 of file EGammaTracksThinning.h.

m_minEtEg

Gaudi::Property<double> DerivationFramework::EGammaTracksThinning::m_minEtEg { this, "minEtEg", 0,""}

private

Definition at line 55 of file EGammaTracksThinning.h.

m_photonsContainerKey

SG::ReadHandleKey<xAOD::PhotonContainer> DerivationFramework::EGammaTracksThinning::m_photonsContainerKey { this, "photonContainerName", "Photons", ""}

private

Definition at line 49 of file EGammaTracksThinning.h.

m_streamName

StringProperty DerivationFramework::EGammaTracksThinning::m_streamName { this, "StreamName", "", "Name of the stream being thinned" }

private

Definition at line 45 of file EGammaTracksThinning.h.

m_tracksCollectionName

SG::ThinningHandleKey<TrackCollection> DerivationFramework::EGammaTracksThinning::m_tracksCollectionName { this, "tracksCollectionName", "Tracks", "" }

private

Definition at line 51 of file EGammaTracksThinning.h.

---

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

• EGammaTracksThinning.h
• EGammaTracksThinning.cxx