#include <JetConstituentFiller.h>

Collaboration diagram for JetConstituentFiller:

Public Types
typedef std::vector< std::string >	NameList

Public Member Functions
	JetConstituentFiller (bool isTrig=false)
int	extractConstituents (xAOD::Jet &jet, const NameList pghostlabs, const fastjet::PseudoJet ppj=0)
	Build and fill constituents of jet from its PseudoJet (or from ppj) Returns the number of pseudojet constituents without user info or < 0 for error.
int	extractConstituents (xAOD::Jet &jet, const fastjet::PseudoJet *ppj=0)
	Build and fill constituents of jet from its PseudoJet (or from ppj) Returns the number of pseudojet constituents without user info or < 0 for error.

Static Public Member Functions
static PseudoJetVector	constituentPseudoJets (const xAOD::Jet &jet, bool ignoreGhosts=true, bool requireJetStructure=false)
	Returns the jet's constituents as a vector of PseudoJet if ignoreGhosts==true, ghost constituents are removed from the output.

Protected Attributes
bool	m_isTrigger

Detailed Description

Definition at line 27 of file JetConstituentFiller.h.

Member Typedef Documentation

◆ NameList

typedef std::vector<std::string> jet::JetConstituentFiller::NameList

Definition at line 33 of file JetConstituentFiller.h.

Constructor & Destructor Documentation

◆ JetConstituentFiller()

jet::JetConstituentFiller::JetConstituentFiller ( bool isTrig = false )

inline

Definition at line 31 of file JetConstituentFiller.h.

31:m_isTrigger(isTrig){}

JetConstituentFiller::m_isTrigger

bool m_isTrigger

Definition JetConstituentFiller.h:57

Member Function Documentation

◆ constituentPseudoJets()

PseudoJetVector JetConstituentFiller::constituentPseudoJets	(	const xAOD::Jet &	jet,
		bool	ignoreGhosts = true,
		bool	requireJetStructure = false )

static

Returns the jet's constituents as a vector of PseudoJet if ignoreGhosts==true, ghost constituents are removed from the output.

Definition at line 169 of file JetConstituentFiller.cxx.

                                                                                                                          {
 
  static const SG::AuxElement::Accessor<const fastjet::PseudoJet*> pjAccessor("PseudoJet");
  const fastjet::PseudoJet* jet_pj = nullptr;
  if(pjAccessor.isAvailable(jet)) jet_pj = pjAccessor(jet);
 
  PseudoJetVector constituents;
 
  if(jet_pj && !ignoreGhosts ){ // Retrieve constituents from the PseudoJet
    constituents = jet_pj->constituents(); // all constituents, including ghosts
    // Removed block for (existing jet_pt and ignoreGhosts), because
    // in the PseudoJetContainer model, the constituent user info is
    // not attached, and hence it's not possible to know if a pj is
    // ghost or constituent.
  } else { // no PseudoJet in jet or need to reject ghosts. Build them from constituents.
 
    // For SoftDrop variables like zg, rg, the structure of the jet is needed and
    // constituents have to be retrieved from the Pseudojet
    if(jet_pj && requireJetStructure){
      PseudoJetVector constituents_all = jet_pj->constituents(); // all constituents, including ghosts
      //Filter out ghosts before calculating variables (comparison to constituents)
      xAOD::JetConstituentVector constituents_tmp = jet.getConstituents();
      constituents.reserve( jet.numConstituents() );
      for(size_t i = 0; i < constituents_all.size(); i++){
    for(size_t j = 0; j < constituents_tmp.size(); j++){
      if(std::abs((constituents_all[i].px()-constituents_tmp[j].Px())/constituents_tmp[j].Px()) < 0.0001 &&
         std::abs((constituents_all[i].py()-constituents_tmp[j].Py())/constituents_tmp[j].Py()) < 0.0001 && 
         std::abs((constituents_all[i].pz()-constituents_tmp[j].Pz())/constituents_tmp[j].Pz()) < 0.0001){
        constituents.push_back(constituents_all[i]);
        break;
      }
    }
      }
    }
    else{
      xAOD::JetConstituentVector constituents_tmp = jet.getConstituents();
      constituents.reserve( jet.numConstituents() );
      for(size_t i = 0; i < constituents_tmp.size(); i++){
    constituents.emplace_back( constituents_tmp[i].Px(), constituents_tmp[i].Py(), constituents_tmp[i].Pz(), constituents_tmp[i].E() );
      }
    }
  }
  return constituents;
}

◆ extractConstituents() [1/2]

int JetConstituentFiller::extractConstituents	(	xAOD::Jet &	jet,
		const fastjet::PseudoJet *	ppj = 0 )

Build and fill constituents of jet from its PseudoJet (or from ppj) Returns the number of pseudojet constituents without user info or < 0 for error.

If the jet does not have an associated pseudojet, then the last argument is used in its place. This is for backwards compatability with code that targets release 19.1

Definition at line 163 of file JetConstituentFiller.cxx.

                                                                                        {
  return extractConstituents(jet, nullptr, ppj2);
}

◆ extractConstituents() [2/2]

int JetConstituentFiller::extractConstituents	(	xAOD::Jet &	jet,
		const NameList *	pghostlabs,
		const fastjet::PseudoJet *	ppj = 0 )

Build and fill constituents of jet from its PseudoJet (or from ppj) Returns the number of pseudojet constituents without user info or < 0 for error.

If the jet does not have an associated pseudojet, then the last argument is used in its place. The second argments holds the list of ghost association names.

Definition at line 40 of file JetConstituentFiller.cxx.

                                                  {
 
  static const SG::AuxElement::Accessor<const fastjet::PseudoJet*> pjAccessor("PseudoJet");
  const fastjet::PseudoJet* ppseudojet = nullptr; 
  if(pjAccessor.isAvailable(jet)) ppseudojet = pjAccessor(jet);
 
  if ( ppseudojet == nullptr ) {
    ppseudojet = ppj2;
  }
  if ( ppseudojet == nullptr ) return -1;
  int nbad = 0;
  const PseudoJetVector& cons = ppseudojet->constituents();
  ParticleMap out;
  MuonSegmentMap outms;
  PtMap ptout;
  ParTypeVector partypes;
  const LabelIndex* pli = nullptr;
  for ( PseudoJetVector::const_iterator icon=cons.begin(); icon!=cons.end(); ++icon ) {
    if ( icon->has_user_info<IConstituentUserInfo>() ) {
      const IConstituentUserInfo& cui = icon->user_info<IConstituentUserInfo>();
      // Initialize with the first constituent.
      if ( pli == nullptr ) {
        pli = cui.labelMap();
        if ( pli == nullptr ) return -2;
        unsigned int maxli = pli->size() + 1;  // +1 because LabelIndex starts at 1;
        out.resize(maxli);  // +1 because LabelIndex starts at 1
        outms.resize(maxli);
        for ( unsigned int ili=0; ili<maxli; ++ili ) {
          ptout.push_back(0.0);
        }
        for ( ParType& partype : partypes ) partype = UNDEF;
        for ( unsigned int idx=0; idx<maxli; ++idx ) {
          std::string lab = pli->label(idx);
          if ( lab.empty() ) {
            partypes.push_back(UNDEF);
            if ( idx ) return -3;
          } else if ( lab.find("MuonSegment") != std::string::npos ) {
            partypes.push_back(MUSEG);
          } else {
            partypes.push_back(IPART);
          }
        }
      }
      if ( pli != cui.labelMap() ) return -4;
      const IParticle* ppar = cui.particle();
      const MuonSegment* pms = nullptr;
      // If this is not an IParticle, find the full type.
      unsigned int icui = cui.index();
      ParType partype = partypes[icui];
      if ( ppar == nullptr ) {
        const MuonSegmentCUI* pmscui = dynamic_cast<const MuonSegmentCUI*>(&cui);
        if ( pmscui == nullptr ) return -5;
        pms = pmscui->object();
        if ( partype != MUSEG ) return -6;
      } else {
        if ( partype != IPART ) return -7;
      }
      Label lab = cui.label();
      // Add to constituent list or associated object list.
      if ( ! cui.isGhost() ) {
        if (!ppar) {
          ++nbad;
        }
        else {
          jet.addConstituent(ppar);
          jet.setConstituentsSignalState( cui.constitScale() );
        }
      } else {
        if ( partype == MUSEG ) {
          outms[icui].push_back(pms); 
        } else if ( partype == IPART ) {
          out[icui].push_back(ppar); 
        } 
      }
    } else {
      ++nbad;
    }
  }
  
  // Set ghost associated particles:
  if (pli){
    for ( size_t i=1; i<out.size(); ++i ) {
      if ( pghostlabs) {
        const NameList& ghostlabs = *pghostlabs;
        if ( find(ghostlabs.begin(), ghostlabs.end(), pli->label(i)) == ghostlabs.end() ) {
          nbad += out[i].size();
          continue;
        }
      }
      ParType& partype = partypes[i];
      std::string cname = pli->label(i) + "Count";
      std::string ptname = pli->label(i) + "Pt";
      // Check if this is in the parent jet
      int count_test; // dummy var to retrieve into -- we don't care about the value
      const static SG::AuxElement::ConstAccessor<ElementLink<xAOD::JetContainer> > cacc_parent("Parent");
      if(!m_isTrigger) {
        if(cacc_parent.isAvailable(jet) && cacc_parent(jet).isValid()) {
          if(!(*cacc_parent(jet))->getAttribute(cname,count_test)) {
            nbad += out[i].size(); // Skip if the parent does not have this
            continue;
          }
        }
      }
      if ( partype == MUSEG ) {
        // Record associated muons.
        jet.setAssociatedObjects(pli->label(i) , outms[i]);
        jet.setAttribute<int>(cname, outms[i].size());
      } else if ( partype == IPART ) {
        // Record associated particles.
        jet.setAssociatedObjects(pli->label(i), out[i]);
        jet.setAttribute<int>(cname, out[i].size());
        jet.setAttribute<float>(ptname, ptout[i]);
        if ( ! outms[i].empty() ) return -9;
      } else {
        return -10;
      }
    }
  }
  return nbad;
}

Member Data Documentation

◆ m_isTrigger

bool jet::JetConstituentFiller::m_isTrigger

protected

Definition at line 57 of file JetConstituentFiller.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Attributes