DerivationFramework::JetCaloClusterThinning Class Reference

#include <JetCaloClusterThinning.h>

Inheritance diagram for DerivationFramework::JetCaloClusterThinning:

Collaboration diagram for DerivationFramework::JetCaloClusterThinning:

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

Private Member Functions
void	setJetClustersMask (std::vector< bool > &, const xAOD::JetContainer *&) const
void	setJetClustersMask (std::vector< bool > &, std::vector< const xAOD::Jet * > &) const

Private Attributes
std::atomic< unsigned int >	m_ntotTopo
std::atomic< unsigned int >	m_npassTopo
StringProperty	m_streamName
SG::ThinningHandleKey< xAOD::CaloClusterContainer >	m_TopoClSGKey { this, "TopoClCollectionSGKey", "CaloCalTopoCluster", "" }
SG::ReadHandleKey< xAOD::JetContainer >	m_sgKey { this, "SGKey", "", "SG key of jet container to thin" }
Gaudi::Property< std::vector< std::string > >	m_addClusterSGKey { this, "AdditionalClustersKey", {}, ""}
SG::ThinningHandleKey< xAOD::CaloClusterContainer >	m_tmpAddClusterKey { this, "TmpAddClustersKey","LCOriginTopoClusters",""}
std::vector< SG::ThinningHandleKey< xAOD::CaloClusterContainer > >	m_addClusterKeys
std::string	m_selectionString

Detailed Description

Definition at line 28 of file JetCaloClusterThinning.h.

Constructor & Destructor Documentation

JetCaloClusterThinning()

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

Definition at line 23 of file JetCaloClusterThinning.cxx.

  : base_class(t, n, p)
  , m_ntotTopo(0)
  , m_npassTopo(0)
  , m_selectionString("")
{
  declareInterface<DerivationFramework::IThinningTool>(this);
  declareProperty("SelectionString", m_selectionString);
}

~JetCaloClusterThinning()

DerivationFramework::JetCaloClusterThinning::~JetCaloClusterThinning ( )

virtualdefault

Member Function Documentation

doThinning()

StatusCode DerivationFramework::JetCaloClusterThinning::doThinning ( ) const

overridevirtual

Definition at line 86 of file JetCaloClusterThinning.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // Retrieve CalCaloTopo collection if required
  SG::ThinningHandle<xAOD::CaloClusterContainer> importedTopoCaloCluster(
    m_TopoClSGKey, ctx);
 
  // Check the event contains tracks
  unsigned int nTopoClusters = importedTopoCaloCluster->size();
  if (nTopoClusters == 0)
    return StatusCode::SUCCESS;
 
  // Set up a mask with the same entries as the full CaloCalTopoClusters collection(s)
  std::vector<bool> topomask;
  topomask.assign(nTopoClusters, false);
  m_ntotTopo += nTopoClusters;
 
  // Retrieve jet container
  const xAOD::JetContainer* importedJets(nullptr);
  SG::ReadHandle<xAOD::JetContainer> importedJetsHandle{ m_sgKey, ctx };
  importedJets = importedJetsHandle.ptr();
  if (importedJets == nullptr) {
    ATH_MSG_ERROR("No jet collection with name " << m_sgKey.key()
                                                 << " found in StoreGate!");
    return StatusCode::FAILURE;
  }
  unsigned int nJets(importedJets->size());
  if (nJets == 0)
    return StatusCode::SUCCESS;
  std::vector<const xAOD::Jet*> jetToCheck;
  jetToCheck.clear();
 
  // Execute the text parsers if requested
  if (!m_selectionString.empty()) {
    std::vector<int> entries = m_parser->evaluateAsVector();
    unsigned int nEntries = entries.size();
    // check the sizes are compatible
    if (nJets != nEntries) {
      ATH_MSG_ERROR("Sizes incompatible! Are you sure your selection string "
                    "used jets objects??");
      return StatusCode::FAILURE;
    } else {
      // identify which e-gammas to keep for the thinning check
      for (unsigned int i = 0; i < nJets; ++i)
        if (entries[i] == 1)
          jetToCheck.push_back((*importedJets)[i]);
    }
 
    if(jetToCheck.empty())
      return StatusCode::SUCCESS;
    
    for( const xAOD::Jet* jet : jetToCheck){
      const auto& links = jet->constituentLinks();
      for( const auto& link : links ) {
        // Check that the link is valid:                                                                                                                                                                    
        if( ! link.isValid() ) {
          continue;
        }
        topomask.at( link.index() ) = true;
      }
    }
  }
  else{
    for( const xAOD::Jet* jet : *importedJets){
      const auto& links = jet->constituentLinks();
      for( const auto& link : links ) {
    // Check that the link is valid:
    if( ! link.isValid() ) {
      continue;
    }
    topomask.at( link.index() ) = true;
      }
    }
  }
 
  // Count up the mask contents
  for (unsigned int i = 0; i < nTopoClusters; ++i) {
    if (topomask[i])
      ++m_npassTopo;
  }
 
  // Execute the thinning service based on the mask. Finish.
  importedTopoCaloCluster.keep(topomask);
 
  for(const auto & addClusterKey : m_addClusterKeys){
    SG::ThinningHandle<xAOD::CaloClusterContainer>  tempClusters(addClusterKey);
    tempClusters.keep(topomask);
  }
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode DerivationFramework::JetCaloClusterThinning::finalize ( )

overridevirtual

Definition at line 75 of file JetCaloClusterThinning.cxx.

{
  ATH_MSG_VERBOSE("finalize() ...");
  ATH_MSG_INFO("Processed " << m_ntotTopo << " topo clusters, of which "
                            << m_npassTopo << " were retained ");
  ATH_CHECK(finalizeParser());
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::JetCaloClusterThinning::initialize ( )

overridevirtual

Definition at line 41 of file JetCaloClusterThinning.cxx.

{
  // Decide which collections need to be checked for ID TrackParticles
  ATH_MSG_VERBOSE("initialize() ...");
  ATH_CHECK(m_TopoClSGKey.initialize(m_streamName));
  ATH_MSG_INFO("Using " << m_TopoClSGKey.key()
                        << "as the source collection for topo calo clusters");
  if (m_sgKey.empty()) {
    ATH_MSG_FATAL("No jet collection provided for thinning.");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_INFO(
      "Calo clusters associated with objects in "
      << m_sgKey.key()
      << " will be retained in this format with the rest being thinned away");
    ATH_CHECK(m_sgKey.initialize());
  }
 
  for(unsigned int i=0; i < m_addClusterSGKey.size(); i++){
    m_tmpAddClusterKey = m_addClusterSGKey[i];
    ATH_CHECK(m_tmpAddClusterKey.initialize(m_streamName));
    m_addClusterKeys.push_back(m_tmpAddClusterKey);
  }
 
  // Set up the text-parsing machinery for selectiong the photon directly
  // according to user cuts
  if (!m_selectionString.empty()) {
    ATH_CHECK(initializeParser(m_selectionString));
  }
 
  return StatusCode::SUCCESS;
}

setJetClustersMask() [1/2]

void DerivationFramework::JetCaloClusterThinning::setJetClustersMask ( std::vector< bool > &  , const xAOD::JetContainer *&    ) const

private

setJetClustersMask() [2/2]

void DerivationFramework::JetCaloClusterThinning::setJetClustersMask ( std::vector< bool > &  , std::vector< const xAOD::Jet * > &    ) const

private

Member Data Documentation

m_addClusterKeys

std::vector<SG::ThinningHandleKey<xAOD::CaloClusterContainer> > DerivationFramework::JetCaloClusterThinning::m_addClusterKeys

private

Definition at line 55 of file JetCaloClusterThinning.h.

m_addClusterSGKey

Gaudi::Property<std::vector<std::string> > DerivationFramework::JetCaloClusterThinning::m_addClusterSGKey { this, "AdditionalClustersKey", {}, ""}

private

Definition at line 53 of file JetCaloClusterThinning.h.

m_npassTopo

std::atomic<unsigned int> DerivationFramework::JetCaloClusterThinning::m_npassTopo

private

Definition at line 42 of file JetCaloClusterThinning.h.

m_ntotTopo

std::atomic<unsigned int> DerivationFramework::JetCaloClusterThinning::m_ntotTopo

mutableprivate

Definition at line 41 of file JetCaloClusterThinning.h.

m_selectionString

std::string DerivationFramework::JetCaloClusterThinning::m_selectionString

private

Definition at line 57 of file JetCaloClusterThinning.h.

m_sgKey

SG::ReadHandleKey<xAOD::JetContainer> DerivationFramework::JetCaloClusterThinning::m_sgKey { this, "SGKey", "", "SG key of jet container to thin" }

private

Definition at line 51 of file JetCaloClusterThinning.h.

m_streamName

StringProperty DerivationFramework::JetCaloClusterThinning::m_streamName

private

Initial value:

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

Definition at line 44 of file JetCaloClusterThinning.h.

m_tmpAddClusterKey

SG::ThinningHandleKey<xAOD::CaloClusterContainer> DerivationFramework::JetCaloClusterThinning::m_tmpAddClusterKey { this, "TmpAddClustersKey","LCOriginTopoClusters",""}

private

Definition at line 54 of file JetCaloClusterThinning.h.

m_TopoClSGKey

SG::ThinningHandleKey<xAOD::CaloClusterContainer> DerivationFramework::JetCaloClusterThinning::m_TopoClSGKey { this, "TopoClCollectionSGKey", "CaloCalTopoCluster", "" }

private

Definition at line 49 of file JetCaloClusterThinning.h.

---

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

• JetCaloClusterThinning.h
• JetCaloClusterThinning.cxx