DerivationFramework::TauTrackParticleThinning Class Reference

#include <TauTrackParticleThinning.h>

Inheritance diagram for DerivationFramework::TauTrackParticleThinning:

Collaboration diagram for DerivationFramework::TauTrackParticleThinning:

Public Member Functions
	TauTrackParticleThinning (const std::string &t, const std::string &n, const IInterface *p)
virtual	~TauTrackParticleThinning ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	doThinning () const override

Private Attributes
std::atomic< unsigned int >	m_ntot {}
std::atomic< unsigned int >	m_npass {}
StringProperty	m_streamName { this, "StreamName", "", "Name of the stream being thinned" }
SG::ThinningHandleKey< xAOD::TrackParticleContainer >	m_inDetSGKey { this, "InDetTrackParticlesKey", "InDetTrackParticles", "" }
SG::ReadHandleKey< xAOD::TauJetContainer >	m_tauKey { this, "TauKey", "", ""}
Gaudi::Property< bool >	m_doTauTracksThinning { this, "DoTauTracksThinning", false, "Apply thinning to tau tracks in addition to ID tracks"}
SG::ThinningHandleKey< xAOD::TauTrackContainer >	m_tauTracksSGKey { this, "TauTracksKey", "TauTracks", "StoreGate key of the tau track container" }
Gaudi::Property< std::string >	m_selectionString { this, "SelectionString", "",""}
Gaudi::Property< float >	m_coneSize { this, "ConeSize", -1.0, ""}

Detailed Description

Definition at line 29 of file TauTrackParticleThinning.h.

Constructor & Destructor Documentation

TauTrackParticleThinning()

DerivationFramework::TauTrackParticleThinning::TauTrackParticleThinning	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 21 of file TauTrackParticleThinning.cxx.

                                                                                              :
base_class(t,n,p)
{
}

~TauTrackParticleThinning()

DerivationFramework::TauTrackParticleThinning::~TauTrackParticleThinning ( )

virtualdefault

Member Function Documentation

doThinning()

StatusCode DerivationFramework::TauTrackParticleThinning::doThinning ( ) const

overridevirtual

Definition at line 69 of file TauTrackParticleThinning.cxx.

{
    const EventContext& ctx = Gaudi::Hive::currentContext();
    
    // Retrieve main TrackParticle collection
    SG::ThinningHandle<xAOD::TrackParticleContainer> importedTrackParticles
      (m_inDetSGKey, ctx);
    
    // Check the event contains tracks
    unsigned int nTracks = importedTrackParticles->size();
    if (nTracks==0) return StatusCode::SUCCESS;
    
    // Set up a mask with the same entries as the full TrackParticle collection
    std::vector<bool> mask;
    mask.assign(nTracks,false); // default: don't keep any tracks
    m_ntot += nTracks;
    
    // Retrieve containers
    // ... taus
    SG::ReadHandle<xAOD::TauJetContainer> importedTaus(m_tauKey,ctx);
    if (!importedTaus.isValid()) {
        ATH_MSG_ERROR("No tau collection with name " << m_tauKey.key() << " found in StoreGate!");
        return StatusCode::FAILURE;
    }
    unsigned int nTaus(importedTaus->size());
    std::vector<const xAOD::TauJet*> tauToCheck; tauToCheck.clear();
    
    // Execute the text parser if requested
    if (!m_selectionString.empty()) {
        std::vector<int> entries =  m_parser->evaluateAsVector();
        unsigned int nEntries = entries.size();
        // check the sizes are compatible
        if (nTaus != nEntries ) {
            ATH_MSG_ERROR("Sizes incompatible! Are you sure your selection string used taus??");
            return StatusCode::FAILURE;
        } else {
            // identify which taus to keep for the thinning check
            for (unsigned int i=0; i<nTaus; ++i) if (entries[i]==1) tauToCheck.push_back((*importedTaus)[i]);
        }
    } else {
      // use all taus if no selection string is passed
      for (unsigned int i=0; i<nTaus; ++i) tauToCheck.push_back((*importedTaus)[i]);
    }
    
    // Set elements in the mask to true if there is a corresponding ElementLink from a reconstructed object
    // ... taus
    DerivationFramework::TracksInCone trIC;
    if (m_selectionString=="") { // check all taus as user didn't provide a selection string
        for (const auto *tauIt : *importedTaus) {
                if (m_coneSize>0.0) trIC.select(tauIt,m_coneSize,importedTrackParticles.cptr(),mask); // check tracks in a cone around the tau if req'd
                for (unsigned int i=0; i<tauIt->nTracks(); ++i) {
          int index = xAOD::TauHelpers::trackParticleLinks(tauIt, xAOD::TauJetParameters::TauTrackFlag::classifiedCharged).at(i).index();
                  mask[index] = true;
                }
        }
    } else { // check only taus passing user selection string
        for (auto & tauIt : tauToCheck) {
            if (m_coneSize>0.0) trIC.select(tauIt,m_coneSize,importedTrackParticles.cptr(),mask); // check tracks in a cone around the tau if req'd 
            for (unsigned int i=0; i<tauIt->nTracks(); ++i) {
          int index = xAOD::TauHelpers::trackParticleLinks(tauIt, xAOD::TauJetParameters::TauTrackFlag::classifiedCharged).at(i).index();
              mask[index] = true;
            }
        }
    }
    
    // Count up the mask contents
    unsigned int n_pass=0;
    for (unsigned int i=0; i<nTracks; ++i) {
        if (mask[i]) ++n_pass;
    }
    m_npass += n_pass;
 
    // Execute the thinning service based on the mask. 
    importedTrackParticles.keep (mask);
 
   // Apply thinning to tau track collection if requested
   if( m_doTauTracksThinning ) {
      SG::ThinningHandle<xAOD::TauTrackContainer> importedTauTracks
      (m_tauTracksSGKey, ctx);
      if( importedTauTracks->empty() ) {
         return StatusCode::SUCCESS;
      }    
      std::vector< bool > mask_tautracks( importedTauTracks->size(), false );
      
      for( const xAOD::TauJet* tau : tauToCheck ) {
         // Get all the associated charged tau tracks:
     auto ttLinks = tau->tauTrackLinks(xAOD::TauJetParameters::TauTrackFlag::classifiedCharged );
     // Process the links:
     for( const auto& ttLink : ttLinks ) {
            if( ! ttLink.isValid() ) {
               continue;
            }
            if( ttLink.dataID() != m_tauTracksSGKey.key() ) {
               ATH_MSG_FATAL( "Charged tau track does not come from "
                              "container \"" << m_tauTracksSGKey << "\"" );
               return StatusCode::FAILURE;
            }
            // If it is, set the mask for it:
            mask_tautracks.at( ttLink.index() ) = true;
         }
         // Select the tau tracks in a cone if it was requested (NOT RECOMMENDED):
     if( m_coneSize > 0.0 ) {
        trIC.select( tau, m_coneSize, importedTauTracks.cptr(), mask_tautracks );
     }
       }
 
       importedTauTracks.keep(mask_tautracks);
    
   }
 
   return StatusCode::SUCCESS;
 
}

finalize()

StatusCode DerivationFramework::TauTrackParticleThinning::finalize ( )

overridevirtual

Definition at line 60 of file TauTrackParticleThinning.cxx.

{
    ATH_MSG_VERBOSE("finalize() ...");
    ATH_MSG_INFO("Processed "<< m_ntot <<" tracks, "<< m_npass<< " were retained ");
    ATH_CHECK( finalizeParser() );
    return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::TauTrackParticleThinning::initialize ( )

overridevirtual

Definition at line 32 of file TauTrackParticleThinning.cxx.

{
    // Decide which collections need to be checked for ID TrackParticles
    ATH_MSG_VERBOSE("initialize() ...");
    ATH_CHECK( m_inDetSGKey.initialize (m_streamName) );
    ATH_MSG_INFO("Using " << m_inDetSGKey << "as the source collection for inner detector track particles");
    if (m_tauKey.key().empty()) {
        ATH_MSG_FATAL("No tau collection provided for thinning.");
        return StatusCode::FAILURE;
    } else { ATH_MSG_INFO("Inner detector track particles associated with objects in " << m_tauKey.key() << " will be retained in this format with the rest being thinned away");}
    ATH_CHECK(m_tauKey.initialize());
    if (m_doTauTracksThinning) {
       if (m_tauTracksSGKey.key().empty()) { 
           ATH_MSG_FATAL("No tau tracks collection provided for thinning, despite this option being requested.");
           return StatusCode::FAILURE;   
       } else {
           ATH_MSG_INFO("Tau track thinning requested; tau tracks with the SG key " << m_tauTracksSGKey.key() << " will be thinned if not associated with objects in " << m_tauKey.key());
           ATH_CHECK( m_tauTracksSGKey.initialize (m_streamName) ); 
       }
    }
 
    // Set up the text-parsing machinery for selectiong the tau directly according to user cuts
    if (!m_selectionString.empty()) {
       ATH_CHECK(initializeParser(m_selectionString) );
    }
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_coneSize

Gaudi::Property<float> DerivationFramework::TauTrackParticleThinning::m_coneSize { this, "ConeSize", -1.0, ""}

private

Definition at line 52 of file TauTrackParticleThinning.h.

m_doTauTracksThinning

Gaudi::Property<bool> DerivationFramework::TauTrackParticleThinning::m_doTauTracksThinning { this, "DoTauTracksThinning", false, "Apply thinning to tau tracks in addition to ID tracks"}

private

Definition at line 46 of file TauTrackParticleThinning.h.

m_inDetSGKey

SG::ThinningHandleKey<xAOD::TrackParticleContainer> DerivationFramework::TauTrackParticleThinning::m_inDetSGKey { this, "InDetTrackParticlesKey", "InDetTrackParticles", "" }

private

Definition at line 42 of file TauTrackParticleThinning.h.

m_npass

std::atomic<unsigned int> DerivationFramework::TauTrackParticleThinning::m_npass {}

mutableprivate

Definition at line 39 of file TauTrackParticleThinning.h.

m_ntot

std::atomic<unsigned int> DerivationFramework::TauTrackParticleThinning::m_ntot {}

mutableprivate

Definition at line 38 of file TauTrackParticleThinning.h.

m_selectionString

Gaudi::Property<std::string> DerivationFramework::TauTrackParticleThinning::m_selectionString { this, "SelectionString", "",""}

private

Definition at line 50 of file TauTrackParticleThinning.h.

m_streamName

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

private

Definition at line 40 of file TauTrackParticleThinning.h.

m_tauKey

SG::ReadHandleKey<xAOD::TauJetContainer> DerivationFramework::TauTrackParticleThinning::m_tauKey { this, "TauKey", "", ""}

private

Definition at line 44 of file TauTrackParticleThinning.h.

m_tauTracksSGKey

SG::ThinningHandleKey<xAOD::TauTrackContainer> DerivationFramework::TauTrackParticleThinning::m_tauTracksSGKey { this, "TauTracksKey", "TauTracks", "StoreGate key of the tau track container" }

private

Definition at line 48 of file TauTrackParticleThinning.h.

---

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

• TauTrackParticleThinning.h
• TauTrackParticleThinning.cxx