PseudoJetGetter Namespace Reference

Implementations of concrete input-to-PseudoJet conversions Separated from PseudoJetAlgorithm for readability. More...

Classes
struct	EMTopoRejecter
struct	IParticleRejecter
struct	PFlowRejecter

Functions
std::vector< fastjet::PseudoJet >	IParticlesToPJs (const xAOD::IParticleContainer &ips, bool skipNegativeEnergy)
std::vector< fastjet::PseudoJet >	EMToposToPJs (const xAOD::IParticleContainer &ips, bool skipNegativeEnergy)
std::vector< fastjet::PseudoJet >	PFlowsToPJs (const xAOD::IParticleContainer &ips, bool skipNegativeEnergy, bool useChargedPFOs, bool useNeutralPFOs, bool useChargedPV, bool useChargedPUsideband, bool isUFO)
std::vector< fastjet::PseudoJet >	ByVertexPFlowsToPJs (const xAOD::IParticleContainer &ips, const xAOD::VertexContainer *pvs, bool skipNegativeEnergy, bool useChargedPFOs, bool useNeutralPFOs, bool isUFO)

Detailed Description

Implementations of concrete input-to-PseudoJet conversions Separated from PseudoJetAlgorithm for readability.

IParticle is the generic type that is normally assumed. Special treatment is needed for two cases:

• EMTopo clusters will be converted at the uncalibrated cluster scale – this is mostly obsolete in offline reco but used by trigger for the moment
• ParticleFlowObjects that are charged will be filtered out if they are not matched to the primary vertex

Function Documentation

ByVertexPFlowsToPJs()

std::vector<fastjet::PseudoJet> PseudoJetGetter::ByVertexPFlowsToPJs	(	const xAOD::IParticleContainer &	ips,
		const xAOD::VertexContainer *	pvs,
		bool	skipNegativeEnergy,
		bool	useChargedPFOs,
		bool	useNeutralPFOs,
		bool	isUFO
	)

Definition at line 217 of file PseudoJetGetter.h.

                                                                                                                                                                        {
 
    const static SG::AuxElement::Accessor<             unsigned  > copyIndex("ConstituentCopyIndex");     // For neutral PFOs
    const static SG::AuxElement::Accessor< std::vector<unsigned> > matchedPVs("MatchingPVs");             // For charged PFOs
    const static SG::AuxElement::Accessor< std::vector<unsigned> > matchedPUSBs("MatchingPUsidebands");   // For charged PFOs
    PFlowRejecter rejecter(skipNegativeEnergy, useChargedPFOs, useNeutralPFOs, false, false, isUFO);
    std::vector<fastjet::PseudoJet> vpj;
    int index = -1;
 
    // loop over the input iparticles, select and  convert to pseudojets
    for(const xAOD::IParticle* ip: ips) {
 
      const xAOD::FlowElement* pfo = dynamic_cast<const xAOD::FlowElement*>(ip);
      ++index;
      if(rejecter(ip)){
        continue;
      }
 
      unsigned vertexIndex{0};
      if (pfo->isCharged())
      {
        // Charged PFOs - use the vertex matched to the track
        if (matchedPVs.isAvailable(*pfo) && matchedPVs(*pfo).size())
        {
          // A charged PFO can potentially match multiple vertices, depending on the matching criteria used
          // For now, just use the first match, to be further optimised later -- TODO
          // Also add the part for PU sidebands -- TODO
          vertexIndex = matchedPVs(*pfo).at(0);
        }
        else{
          continue;
        }
      }
      else
      {
        // Neutral PFOs - there is one neutral PFO corrected to point to each vertex of interest
        // As such, just get the vertex index that this neutral PFO corresponds to
        if (copyIndex.isAvailable(*pfo)){
          vertexIndex = copyIndex(*pfo);
        }
        else{
          continue;         
        }
      }
    
      // Create a Pseudojet with the momentum of the selected IParticles.
      fastjet::PseudoJet psj(ip->p4());
 
 
      // Get the specified vertex and build the VertexIndexedConstituentUserInfo
      for (const xAOD::Vertex* vertex : *pvs)
        if (vertex->index() == vertexIndex){
          // vertex indexed constituent info associated to the pseudojet
          psj.set_user_info(new jet::VertexIndexedConstituentUserInfo(vertex));
 
          // user index is used to identify the xAOD object used for the PSeudoJet
          psj.set_user_index(index);
 
          vpj.push_back(psj);
        }
    }
    return vpj;
  }

EMToposToPJs()

std::vector<fastjet::PseudoJet> PseudoJetGetter::EMToposToPJs	(	const xAOD::IParticleContainer &	ips,
		bool	skipNegativeEnergy
	)

Definition at line 88 of file PseudoJetGetter.h.

                                                                           {
 
    // helper objects for selecting iparticles to be converted to pseudojets
    IParticleRejecter ipRejecter(skipNegativeEnergy);
    EMTopoRejecter emRejecter;
  
    std::vector<fastjet::PseudoJet> vpj;
    int index = -1;
 
    // loop over iparticles, select and  convert to pseudojets
 
    for(const xAOD::IParticle* ip: ips) {
      ++index;
      if(ipRejecter(ip) or emRejecter(ip)){continue;}
    
      // Create a Pseudojet with the momentum of the cluster.
      fastjet::PseudoJet 
    psj(emRejecter.cluster->p4(xAOD::CaloCluster::UNCALIBRATED));
    
      // user index is used to identify the xAOD object used for the PseudoJet
      psj.set_user_index(index); 
      vpj.push_back(psj);
    }
    return vpj;
  }

IParticlesToPJs()

std::vector<fastjet::PseudoJet> PseudoJetGetter::IParticlesToPJs	(	const xAOD::IParticleContainer &	ips,
		bool	skipNegativeEnergy
	)

Definition at line 51 of file PseudoJetGetter.h.

                                                                              {
 
    IParticleRejecter rejecter(skipNegativeEnergy);
 
    std::vector<fastjet::PseudoJet> vpj;
    int index = -1;
 
    // loop over the input iparticles, select and  convert to pseudojets
    for(const xAOD::IParticle* ip: ips) {
      ++index;
      if(rejecter(ip)){continue;}
    
      // Create a Pseudojet with the momentum of the selected IParticles.
      fastjet::PseudoJet psj(ip->p4());
 
      // user index is used to identify the xAOD object used for the PseudoJet
      psj.set_user_index(index); 
      vpj.push_back(psj);
 
    }
    return vpj;
  }

PFlowsToPJs()

std::vector<fastjet::PseudoJet> PseudoJetGetter::PFlowsToPJs	(	const xAOD::IParticleContainer &	ips,
		bool	skipNegativeEnergy,
		bool	useChargedPFOs,
		bool	useNeutralPFOs,
		bool	useChargedPV,
		bool	useChargedPUsideband,
		bool	isUFO
	)

Definition at line 193 of file PseudoJetGetter.h.

                                                                                                                                                                              {
 
    PFlowRejecter rejecter(skipNegativeEnergy, useChargedPFOs, useNeutralPFOs, useChargedPV, useChargedPUsideband, isUFO);
    std::vector<fastjet::PseudoJet> vpj;
    int index = -1;
 
    // loop over the input iparticles, select and  convert to pseudojets
 
    for(const xAOD::IParticle* ip: ips) {
      ++index;
      if(rejecter(ip)){continue;}
    
      // Create a PSeudojet with the momentum of the selected IParticles.
      fastjet::PseudoJet psj(ip->p4());
 
      // user index is used to identify the xAOD object used for the PSeudoJet
      psj.set_user_index(index);
 
      vpj.push_back(psj);
    }
    return vpj;
  }