DerivationFramework::GenericTruthThinning Class Reference

#include <GenericTruthThinning.h>

Inheritance diagram for DerivationFramework::GenericTruthThinning:

Collaboration diagram for DerivationFramework::GenericTruthThinning:

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

Private Attributes
std::atomic< unsigned int >	m_ntotvtx
std::atomic< unsigned int >	m_ntotpart
std::atomic< unsigned int >	m_npassvtx
std::atomic< unsigned int >	m_npasspart
StringProperty	m_streamName { this, "StreamName", "", "Name of the stream being thinned" }
SG::ThinningHandleKey< xAOD::TruthParticleContainer >	m_particlesKey { this, "ParticlesKey", "TruthParticles", "" }
SG::ThinningHandleKey< xAOD::TruthVertexContainer >	m_verticesKey { this, "VerticesKey", "TruthVertices", "" }
std::string	m_eventsKey
std::string	m_partString
bool	m_preserveDescendants
bool	m_preserveGeneratorDescendants
bool	m_preserveAncestors
bool	m_tauHandling

Detailed Description

Definition at line 28 of file GenericTruthThinning.h.

Constructor & Destructor Documentation

GenericTruthThinning()

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

Definition at line 24 of file GenericTruthThinning.cxx.

                                                                                        :
base_class(t,n,p),
m_ntotvtx(0),
m_ntotpart(0),
m_npassvtx(0),
m_npasspart(0),
m_partString(""),
//m_vtxString(""),
m_preserveDescendants(false),
m_preserveGeneratorDescendants(false),
m_preserveAncestors(false),
m_tauHandling(true)
{
    declareProperty("EventsKey", m_eventsKey);
    declareProperty("ParticleSelectionString", m_partString);
    //declareProperty("VertexSelectionString", m_vtxString);
    declareProperty("PreserveDescendants", m_preserveDescendants);
    declareProperty("PreserveGeneratorDescendants", m_preserveGeneratorDescendants);
    declareProperty("PreserveAncestors", m_preserveAncestors);
    declareProperty("TauHandling", m_tauHandling);
}

~GenericTruthThinning()

DerivationFramework::GenericTruthThinning::~GenericTruthThinning ( )

virtual

Definition at line 49 of file GenericTruthThinning.cxx.

                                                               {
}

Member Function Documentation

doThinning()

StatusCode DerivationFramework::GenericTruthThinning::doThinning ( ) const

overridevirtual

Definition at line 86 of file GenericTruthThinning.cxx.

{
    const EventContext& ctx = Gaudi::Hive::currentContext();
    
    // Retrieve truth collections
    SG::ThinningHandle<xAOD::TruthParticleContainer> importedTruthParticles
      (m_particlesKey, ctx);
    SG::ThinningHandle<xAOD::TruthVertexContainer> importedTruthVertices
      (m_verticesKey, ctx);
 
    const xAOD::TruthEventContainer* importedTruthEvents;
    if (evtStore()->retrieve(importedTruthEvents,m_eventsKey).isFailure()) {
        ATH_MSG_ERROR("No TruthEventContainer with name " << m_eventsKey << " found in StoreGate!");
        return StatusCode::FAILURE;
    }
 
 
    
    // Set up a mask with the same entries as the full collections
    unsigned int nParticles = importedTruthParticles->size();
    unsigned int nVertices = importedTruthVertices->size();
    std::vector<bool> partMask, vertMask;
    partMask.assign(nParticles,false); // default: don't keep any truth items
    vertMask.assign(nVertices,false);
    m_ntotvtx += nVertices; m_ntotpart += nParticles;
 
    // Execute the text parsers and update the mask
    if (!m_partString.empty()) {
        std::vector<int> entries =  m_parser->evaluateAsVector();
        unsigned int nEntries = entries.size();
        // check the sizes are compatible
        if (nParticles != nEntries ) {
            ATH_MSG_ERROR("Sizes incompatible! Are you sure your selection string used TruthParticles?");
            return StatusCode::FAILURE;
        } else {
            // set mask
            for (unsigned int i=0; i<nParticles; ++i) if (entries[i]==1) partMask[i]=true;
        }
    }
 
    // Special treatment of taus such that only the last one in the chain is kept 
    // Needs another run over the particle collection
    if (m_tauHandling) {
        DerivationFramework::DecayGraphHelper tauDecayHelper;
        for (unsigned int i=0; i<nParticles; ++i) {
            const xAOD::TruthParticle* particle = (*importedTruthParticles)[i];
            if ( MC::isTau(particle) ) { // This is a tau
                bool last(true);
                std::vector<int> tauDecayProducts; // all decay products of the tau
                std::unordered_set<int> tauDecayEncounteredUniqueIDs; // loop checking
                tauDecayHelper.descendants(particle,tauDecayProducts,tauDecayEncounteredUniqueIDs); // recursive
                for (unsigned int tauDecIt=0; tauDecIt<tauDecayProducts.size(); ++tauDecIt) {
                    if (abs(tauDecayProducts[tauDecIt])==15) { // any taus in the decay products?
                        last = false;
                        break;
                    }
                }
                if (!last) partMask[i]=false;
            } // end of code for tau
        } // end of loop over particles for tau checking  
    } // end of tau handling option
 
    // If user requested preservation of descendants/ancestors:
    // - loop over the masks and work out which particles need to be descended/ascended from
    // - do the recursive loop
    // - update the masks including the descendants/ancestors
    // To ensure graph completeness, this  over-rides anything set by the special treatment 
    // of taus in the section above 
    DerivationFramework::DecayGraphHelper decayHelper;
    std::unordered_set<int> encounteredUniqueIDs; // to enable loop handling
    if (m_preserveDescendants || m_preserveGeneratorDescendants  || m_preserveAncestors) {
        for (unsigned int i=0; i<nParticles; ++i) {
            bool toKeep = partMask[i];
            if (!toKeep) continue;
            const xAOD::TruthParticle* particle = (*importedTruthParticles)[i];
            encounteredUniqueIDs.clear();
            if (m_preserveDescendants) decayHelper.descendants(particle,partMask,vertMask,encounteredUniqueIDs,true);
            encounteredUniqueIDs.clear();
            if (m_preserveGeneratorDescendants) decayHelper.descendants(particle,partMask,vertMask,encounteredUniqueIDs,false);
            encounteredUniqueIDs.clear();
        if (m_preserveAncestors) decayHelper.ancestors(particle,partMask,vertMask,encounteredUniqueIDs);
        encounteredUniqueIDs.clear();
        }
    }
    //for (unsigned int i=0; i<nVertices; ++i) {
    //    bool toKeep = vertMask[i];
    //    if (!toKeep) continue;
    //    const xAOD::TruthVertex* vertex = (*importedTruthVertices)[i];
    //    decayHelper.descend(vertex,partMask,vertMask);
    //}
   
    // Count the masks
    m_npasspart += std::count (partMask.begin(), partMask.end(), true);
    m_npassvtx  += std::count (vertMask.begin(), vertMask.end(), true);
    
    // Execute the thinning service based on the mask. Finish.
    importedTruthParticles.keep (partMask);
    importedTruthVertices.keep  (vertMask);
    
    return StatusCode::SUCCESS;
}

finalize()

StatusCode DerivationFramework::GenericTruthThinning::finalize ( )

overridevirtual

Definition at line 76 of file GenericTruthThinning.cxx.

{
    ATH_MSG_VERBOSE("finalize() ...");
    ATH_MSG_INFO("Processed "<< m_ntotvtx <<" truth vertices, "<< m_npassvtx << " were retained ");
    ATH_MSG_INFO("Processed "<< m_ntotpart <<" truth particles, "<< m_npasspart << " were retained ");
    ATH_CHECK(finalizeParser());
    return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::GenericTruthThinning::initialize ( )

overridevirtual

Definition at line 53 of file GenericTruthThinning.cxx.

{
    ATH_MSG_VERBOSE("initialize() ...");
    ATH_CHECK( m_particlesKey.initialize (m_streamName) );
    ATH_CHECK( m_verticesKey.initialize (m_streamName) );
    ATH_MSG_INFO("Using " << m_particlesKey.key() << " and "<< m_verticesKey.key() << " as the source collections for truth thinning");
    
    if (m_partString.empty()/* && m_vtxString==""*/) {
        ATH_MSG_FATAL("No selection string provided either for vertices or particles!");
        return StatusCode::FAILURE;
    } else {ATH_MSG_INFO("Truth thinning selection strings: " << m_partString /*<< " " << m_vtxString*/);}
   
    if (m_preserveDescendants && m_preserveGeneratorDescendants) {
    ATH_MSG_FATAL("You are asking to keep both all descendants, and only those from the event generator. Please check your job options.");
        return StatusCode::FAILURE;
    }
    // Set up the text-parsing machinery for thinning the truth directly according to user cuts
    if (!m_partString.empty()) {
       ATH_CHECK( initializeParser(m_partString) );
    }
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_eventsKey

std::string DerivationFramework::GenericTruthThinning::m_eventsKey

private

Definition at line 44 of file GenericTruthThinning.h.

m_npasspart

std::atomic<unsigned int> DerivationFramework::GenericTruthThinning::m_npasspart

private

Definition at line 37 of file GenericTruthThinning.h.

m_npassvtx

std::atomic<unsigned int> DerivationFramework::GenericTruthThinning::m_npassvtx

private

Definition at line 37 of file GenericTruthThinning.h.

m_ntotpart

std::atomic<unsigned int> DerivationFramework::GenericTruthThinning::m_ntotpart

private

Definition at line 37 of file GenericTruthThinning.h.

m_ntotvtx

std::atomic<unsigned int> DerivationFramework::GenericTruthThinning::m_ntotvtx

mutableprivate

Definition at line 37 of file GenericTruthThinning.h.

m_particlesKey

SG::ThinningHandleKey<xAOD::TruthParticleContainer> DerivationFramework::GenericTruthThinning::m_particlesKey { this, "ParticlesKey", "TruthParticles", "" }

private

Definition at line 40 of file GenericTruthThinning.h.

m_partString

std::string DerivationFramework::GenericTruthThinning::m_partString

private

Definition at line 45 of file GenericTruthThinning.h.

m_preserveAncestors

bool DerivationFramework::GenericTruthThinning::m_preserveAncestors

private

Definition at line 49 of file GenericTruthThinning.h.

m_preserveDescendants

bool DerivationFramework::GenericTruthThinning::m_preserveDescendants

private

Definition at line 47 of file GenericTruthThinning.h.

m_preserveGeneratorDescendants

bool DerivationFramework::GenericTruthThinning::m_preserveGeneratorDescendants

private

Definition at line 48 of file GenericTruthThinning.h.

m_streamName

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

private

Definition at line 38 of file GenericTruthThinning.h.

m_tauHandling

bool DerivationFramework::GenericTruthThinning::m_tauHandling

private

Definition at line 50 of file GenericTruthThinning.h.

m_verticesKey

SG::ThinningHandleKey<xAOD::TruthVertexContainer> DerivationFramework::GenericTruthThinning::m_verticesKey { this, "VerticesKey", "TruthVertices", "" }

private

Definition at line 42 of file GenericTruthThinning.h.

---

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

• GenericTruthThinning.h
• GenericTruthThinning.cxx