DerivationFramework::TriggerGenericObjectThinningTool Class Reference

#include <TriggerGenericObjectThinningTool.h>

Inheritance diagram for DerivationFramework::TriggerGenericObjectThinningTool:

Collaboration diagram for DerivationFramework::TriggerGenericObjectThinningTool:

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

Private Member Functions
bool	eventPassedFilter () const

Private Attributes
StringProperty	m_streamName { this, "StreamName", "", "Name of the stream being thinned" }
SG::ThinningHandleKey< xAOD::IParticleContainer >	m_SGKey { this, "ContainerName", "", "" }
Gaudi::Property< std::vector< std::string > >	m_triggerListAND {this,"TriggerListAND", {}}
Gaudi::Property< std::vector< std::string > >	m_triggerListOR {this,"TriggerListOR", {}}
Gaudi::Property< std::vector< std::string > >	m_triggerListORHLTOnly {this,"TriggerListORHLTOnly", {}, "Decision is based on HLT only (unseeded triggers)"}
PublicToolHandle< Trig::TrigDecisionTool >	m_trigDec {this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool"}

Detailed Description

Definition at line 30 of file TriggerGenericObjectThinningTool.h.

Constructor & Destructor Documentation

TriggerGenericObjectThinningTool()

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

Definition at line 37 of file TriggerGenericObjectThinningTool.cxx.

                                                                                          :
    base_class(t,n,p)
    {
    }

~TriggerGenericObjectThinningTool()

DerivationFramework::TriggerGenericObjectThinningTool::~TriggerGenericObjectThinningTool

(

)

Definition at line 45 of file TriggerGenericObjectThinningTool.cxx.

                                                                        {
    }

Member Function Documentation

doThinning()

StatusCode DerivationFramework::TriggerGenericObjectThinningTool::doThinning ( const EventContext & ctx ) const

overridevirtual

Definition at line 67 of file TriggerGenericObjectThinningTool.cxx.

    {
        
        // Retrieve main object collection
        SG::ThinningHandle<xAOD::IParticleContainer> particles (m_SGKey, ctx);
    
        // Check the event contains objects
        unsigned int nObjects = particles->size();
        if (nObjects==0) return StatusCode::SUCCESS;
 
        //check if the trigger passed for the event
        bool keep_container = eventPassedFilter();
        
        // Set up a mask with the same entries as the full collection
        std::vector<bool> mask;
        mask.assign(nObjects,keep_container);
        
 
        // Execute the thinning based on the mask. Finish.
        particles.keep (mask);
        
        return StatusCode::SUCCESS;
    }

eventPassedFilter()

bool DerivationFramework::TriggerGenericObjectThinningTool::eventPassedFilter ( ) const

private

Definition at line 5 of file TriggerGenericObjectThinningTool.cxx.

    {
        if (msgLvl(MSG::VERBOSE)){
            const Trig::ChainGroup* Chain = m_trigDec->getChainGroup(".*");
            const std::vector<std::string> fired_triggers = Chain->getListOfTriggers();
            for (const std::string& fired : fired_triggers) {
                if (m_trigDec->isPassed(fired)) ATH_MSG_VERBOSE("Fired trigger "<<fired);
            }
        }
 
        unsigned int cntrAND{0}, cntrOR{0}, cntrORHLTOnly{0};
        for (const std::string& trig_and : m_triggerListAND) {
            ATH_MSG_DEBUG("AND - Trigger "<<trig_and<<" passed "<<m_trigDec->isPassed(trig_and));
            cntrAND+=(m_trigDec->isPassed(trig_and));
        }
        for (const std::string& trig_or : m_triggerListOR) {
            ATH_MSG_DEBUG("OR - Trigger "<<trig_or<<" passed "<<m_trigDec->isPassed(trig_or));
            cntrOR +=(m_trigDec->isPassed(trig_or));
        }
        for (const std::string& trig_orhltonly : m_triggerListORHLTOnly) {
            ATH_MSG_DEBUG("ORHLTOnly - Trigger "<<trig_orhltonly<<" passed "<<m_trigDec->isPassed(trig_orhltonly, TrigDefs::requireDecision));
            cntrORHLTOnly +=(m_trigDec->isPassed(trig_orhltonly, TrigDefs::requireDecision));
        }
 
        bool passAND = (cntrAND==m_triggerListAND.size() && !m_triggerListAND.empty());
        bool passOR = (cntrOR > 0);
        bool passORHLTOnly = (cntrORHLTOnly > 0);
 
        bool pass = passAND || passOR || passORHLTOnly;
        return pass;
    }

finalize()

StatusCode DerivationFramework::TriggerGenericObjectThinningTool::finalize ( )

overridevirtual

Definition at line 60 of file TriggerGenericObjectThinningTool.cxx.

    {
        ATH_MSG_VERBOSE("finalize() ...");
        return StatusCode::SUCCESS;
    }

initialize()

StatusCode DerivationFramework::TriggerGenericObjectThinningTool::initialize ( )

overridevirtual

Definition at line 49 of file TriggerGenericObjectThinningTool.cxx.

    {
        ATH_MSG_VERBOSE("initialize() ...");
 
        //check xAOD::InDetTrackParticle collection
        ATH_CHECK( m_SGKey.initialize (m_streamName) );
        ATH_MSG_INFO("Using " << m_SGKey << "as the source collection");
            
        return StatusCode::SUCCESS;
    }

Member Data Documentation

m_SGKey

SG::ThinningHandleKey<xAOD::IParticleContainer> DerivationFramework::TriggerGenericObjectThinningTool::m_SGKey { this, "ContainerName", "", "" }

private

Definition at line 41 of file TriggerGenericObjectThinningTool.h.

{ this, "ContainerName", "", "" };

m_streamName

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

private

Definition at line 39 of file TriggerGenericObjectThinningTool.h.

{ this, "StreamName", "", "Name of the stream being thinned" };

m_trigDec

PublicToolHandle<Trig::TrigDecisionTool> DerivationFramework::TriggerGenericObjectThinningTool::m_trigDec {this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool"}

private

Definition at line 48 of file TriggerGenericObjectThinningTool.h.

{this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool"};

m_triggerListAND

Gaudi::Property<std::vector<std::string> > DerivationFramework::TriggerGenericObjectThinningTool::m_triggerListAND {this,"TriggerListAND", {}}

private

Definition at line 45 of file TriggerGenericObjectThinningTool.h.

{this,"TriggerListAND", {}};

m_triggerListOR

Gaudi::Property<std::vector<std::string> > DerivationFramework::TriggerGenericObjectThinningTool::m_triggerListOR {this,"TriggerListOR", {}}

private

Definition at line 46 of file TriggerGenericObjectThinningTool.h.

{this,"TriggerListOR", {}};

m_triggerListORHLTOnly

Gaudi::Property<std::vector<std::string> > DerivationFramework::TriggerGenericObjectThinningTool::m_triggerListORHLTOnly {this,"TriggerListORHLTOnly", {}, "Decision is based on HLT only (unseeded triggers)"}

private

Definition at line 47 of file TriggerGenericObjectThinningTool.h.

{this,"TriggerListORHLTOnly", {}, "Decision is based on HLT only (unseeded triggers)"};

---

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

• TriggerGenericObjectThinningTool.h
• TriggerGenericObjectThinningTool.cxx