Explanation of Emerging Jets Variables

The following provides a general description for many of the jet related variables that might be of use.

General Jet Variables

Many of these variables are defined in either the xAOD or xAODHelpers framework and are not EJ specific variables. A similar reference for the jet moments can be found in Run2JetMoments.

For the following values unless otherwise specified the suma are over each jet's constituents

• float _Timing = sum of constituents' times multiplied by their energy squared divided by the sum of all constituents' squared energies
• float _LArQuality = sum of constituents' energies multiplied by the fraction of energy from bad LAr cells divided by the sum of all constituents' energies
• float _HECQuality = sum of constituents' energies from the HEC (Hadronic End Cap) multiplied by the fraction of energy from bad LAr cells divided by the sum of all constituents' HEC energies
• float _NegativeE = sum of the difference between constituents' total energies and negative energies
• float _AverageLArQF = sum of constituents' average LAr energy multiplied by their energy squared divided by the sum of all constituents' energies
• float _BchCorrCel = sum of constituents' total bad cell energies divided by the jet's total energy
• float _N90Constituents = the maximum number of calorimeter cells such that the sum of their energies represents 90% of the total energy of all cells
• float _OotFracClusters[5/10] = sum of the energies for constituents whose times were greater than the specified time cut ([5/10]) divided by the sum of all constituents' energies
• float _CentroidR = sqrt(cx^2+cy^2+cz^2), where each component is calculated as: ci = sum of constituents' i positions multiplied by their energies divided by the sum of all constituents' energies

The above values are calculated in class JetCaloCalculations The calculation steps are defined in class JetCaloQualityUtils The selection of which calculations to perform is determined in class JetCaloQualityTool

• float _LArBadHVEnergyFrac = sum of the energies of bad cells in constituents divided by the jet's energy
• int _LArBadHNVCell = sum of the number of bad cells for each constituent

The above values are calculated in class JetLarHVTool

• float _LeadingCluster[....] - [...] = [Pt, SecondLambda, CenterLambda, SecondR ] - The cluster with the greated pt is the leading cluster
  • _LeadingClusterPt = pt of leading cluster
  • _LeadingClusterSecondLambda = sum of the leading clusters' cells lambda values squared multiplied by their energies
  • _LeadingClusterCenterLambda = shower depth at cluster centroid
  • _LeadingClusterSecondR = sum of the leading clusters' cells r values squared multiplied by their energies

The above values are calculated in class JetClusterMomentsTool

• int _clean_pass[Loose/Tight]Bad[Ugly] = 1 or 0 depending on whether the jet passed the relevant cuts (Loose/Tight with or without Ugly cut also applied)
  • Loose cut returns 0 if (FracSamplingMax>0.99 && fabs(jet.eta()) < 2) || (HECFrac>0.5 && fabs(HECQuality)>0.5 && AverageLArQF/65535>0.8) || (EMFrac>0.95 && fabs(LArQuality)>0.8 && fabs(jet.eta())<2.8 && AverageLArQF/65535>0.8) || (EMFrac && fabs(eta) >= 2) || (emf<0.05 && chf<0.05 && std::fabs(eta)<2)
  • Tight cut returns 0 if Loose cut returns 0 or if FracSamplingMax<DBL_MIN) || (fabs(jet.eta())<2.4 && sumpttrk/pt/fmax<0.1)
  • Ugly cut returns 0 if the MaxFracSamplingIndex == 17

The above value is set in class JetCalibrator The cuts are applied in class JetCleaningTool

• float _HECFrac = the fraction of jet energy in the HEC (Hadronic End Cap)
• float _EMFrac = the fraction of jet energy in the main detector (outside the main detector including the HEC, the tile gaps and external regions (TileGap & TileExt), and the forward calorimeter regions (FCAL1 & FCAL2)) * The calculations are different depending on if the jet is EMTopo or PFlow, for exact calculation of these values refer to the JetCaloEnergies class

The above values are calculated in class JetCaloEnergies

• float _LowEtConstituentsFrac - This variable could not be found, its values are set using the safefill method which returns a default value of -999 when it cannot access the attribute

• float _FracSamplingMax = the fraction of the total jet energy contained in the highest energy jet constituent
• int _FracSamplingMaxIdex = the index of the highest energy jet constituent

The above values are set in class JetCaloQualityTool The values are calculated using JetCaloQualityUtils::fracSamplingMax() in class JetCaloQualityUtils

• float _GhostMuonSegmentCount - The calculations for this variable could not be found

• float _Width = sum of the constituents' ΔR values multiplied by their pt values divided by the sum of the constituent's pt values

The above value is calculated in class JetWidthTool

• vector _NumTrkPt[1000/500] = vector of the number of tracks associated with each of the jet's vertices with pt >= [1000/500]
• vector _SumPtTrkPt[1000/500] = vector containing the sums of the pt values for each track associated with each of the jet's vertices that has pt >= [1000/500]
• vector _TrackWidthPt[1000/500] = vector containing the sum of the widths (ΔR) for each track associated with each of the jet's vertices that has pt >= [1000/500]
• int _NumPtTrkPt[1000/500]PV - Presumed to be the number of tracks in the primary vertex which have pt >= [1000/500]
• float _SumPtTrkPt[1000/500]PV - Presumed to be the sum of the pt for the tracks associated to the primary vertex which have pt >= [1000/500]
• float _TrackWidthPt[1000/500]PV - Presumed to be the sum of the widths for each track associated with the primary vertex which have pt >= [1000/500]
  • The exact source of the PV variables could not be found

The above values are calculated in class JetTrackMoments

• vector _JVF = vector of the fraction of pt for tracks associated to a vertex divided by the total sum for all tracks from vertices associated to the jet
• float jvfcorr = sum of the pt for tracks associated to the primary vertex divided by the sum of pt for primary vertex tracks plus the sum of the pt for the other tracks divided by the number of pileup tracks multiplied by 0.01
  • The value of 0.01 is set in the header file as m_kcorrJVF
  • Tracks are considered to be pileups if it is associated with a non-primary vertex and has a pt of less than 30000, where 30000 is set in the header file as m_PUtrkptcut
• float _JVFPV - Presumed to be the JVF value for the primary vertex The exact source of this variable could not be found

The above values are calculated in class JetVertexFractionTool

• float _Jvt - intepolated value based on jvfcorr and JvtRpt, interpolates from JVT likelihood histogram JVTRootCore_kNN100trim_pt20to50_Likelihood which is set in the header
• float _JvtJvfcorr - This variable could not be found, its values are set using the safefill method which returns a default value of -999 when it cannot access the attribute
  • This might be referring to the jvfcorr variable
• float _JvtRpt = ratio of the primary vertex track sum to the jet's pt

The above values are calculated in class JetVertexTaggerTool More info on vertex taggin can be found at JetVertexTagger, however the cuts listed in it may be outdated as they don't match with the cut statistics in class JetSelector

• int _JvtPass_[Loose/Medium/Tight] = 0 if jet does not pass JVT cuts
• int _fJvtPass_[Medium/Tight] = o if jet does not pass JVT cuts for forward JVT
• vector _JvtEff_SF_[Loose/Medium/Tight] = vector of scale factors for given JvtCut [Loose/Medium/Tight]
• vector _fJvtEff_SF_[Medium/Tight] = vector of scale factors for forward JVT given JvtCut [Medium/Tight]

The above values are calculated in class JetJvtEfficiency

ΔR Matching

ObjectMatcher

ΔR Matched Tracks [Reco Only]

The matching is performed in ObjectMatcher::matchTracksToJets(jets, tracks, jet_type, jet_string)

For each jet the function iterates over all the tracks and calculated the ΔR value between the two. If the ΔR is less than a given cut value set in the header (m_jet_trk_matchRadius, currently 0.4) the relevant jet and track are tentatively matched. A map is made with each tentatively matched track as its keys and where the values are vectors of pairs of the matched jet and the ΔR value. A second map is also created with tracks as keys but the values consist of a single jet and ΔR pair. The first map is iterated over and for each track the jet - ΔR pair with the lowest ΔR value is chosen and set a the value for the track in the second map. This allows each track to be assigned the jet - ΔR pair for the closest jet to the track and the two are matched. Finally two new maps are made where the keys are the various jet objects and the values are vectors of either track element links or ΔR values. For each matched track an element link is created and is placed in the vector of links for the matched jet. A similar process adds the ΔR values for each matched track to the vector of the corresponding jet. Each track is decorated with the fact that it was matched, the ID and index of the matched jet and the ΔR value between the two. Finally each jet is decorated with both the vector of track links and the vector of ΔR values.

• int *Count = number of tracks with valid links matched to a given jet
• float *Pt = sum of the pt for all tracks matched to the jet
• vector *_ID = vector of all matched tracks' IDs
• vector *_index = vector of all matched tracks' indices
• vector *_qOverP = vector of (q/P) values for each matched track
• vector *_[pt/eta/phi/E/M] = vector of associated values for each matched track
• vector *_[d0/z0] = vector of d0 and v0 values for each matched track
• vector *_dR = vector of ΔR values for each matched track

ΔR Matched Secondary Vertices [Reco Only]

the matching is performed in ObjectMatcher::matchSecVertsToJets(jets, secVerts, jet_type, jet_string)

For each jet the function iterates over all the secondary vertices. For each vertex 3 vectors containing track particles are created: filteredTracks, cleanTracks, allTracks, and these are filled using EJsHelper::getFilteredTracks(), EJsHelper::getCleanTracks(), EJsHelper::getAllTracks() respectively. For all three track vectors a TLorentzVector is created using the function VsiBonsai::sumP4 which returns a TLorentzVector representing the sum of each track's TLorentzVector. For each sum TLorentzVector the ΔR value between it and the given jet is calculated. If the ΔR value for at least one of the three TLorentzVectors is less than a given cut value set in the header (m_jet_vtx_matchRadius, currently 0.4) then the secondary vertex and the jet are tentatively matched. A map is made with secondary vertices as keys and vectors of jet -ΔR pairs as values. The ΔR used is the lowest ΔR calculated. A second map is created with secondary vertices as keys but with only a single jet - ΔR pair as keys, representing the closest (and therefore matched) jet to the given secondary vertex. Two maps are then created with jets as keys and whose values are vectors of either vertex container element links or ΔR values. Links are created for each matched secondary vertex and inserted into the vector of the matched jet, and similarly the ΔR value is added to the respective jet's vector. The secondary vertices are decorated as having been matched, as well as being given the ID and index of the matched jet and the ΔR between them. Finally each jet is decorated with a vector of the vertex container links as well as with the vector of ΔR values.

• int *Count = number of secondary vertices matched to a given jet
• vector *_dR = vector of ΔR values between matched secondary vertices and the associated jet
• vector *_ID = vector of the matched secondary vertices' IDs
• vector *_index = vetor of the matched secondary vertices' indices
• vector *_[x/y/z/r] = vector of the position information for each of the matched secondary vertices
• vector *_chi2 = vector of the reduced chi squared values for each of the matched secondary vertices, the chi squared being that of the track fit
• vector *_ntrk[_clean/filt] - vector of the sizes for allTracks, cleanTracks, and fileteredTracks (which are the vectors containing the relevant tracks)

The filtered and clean specifiers refer to the cuts applied in class SecondaryVertexSelector. For filtered tracks any track that fails any of the trimmers defined in VSiBonsai fails, otherwise if is labeled as filtered (isFiltered = 1). Clean tracks are those without bad d0 values, and this is determined using the VsiBonsai::cleanAssociatedD0() function. If a track does not have a bad d0 value then it is considered clean (isClean = 1).

ΔR Matched Truth Vertices [MC Only]

The matching is performed in ObjectMatcher::matchTruthVertsToJets(jets, truthVerts, jet_type, jet_string)

For each jet the function iterates over all the secondary vertices and calculates the ΔR value between them. if the ΔR value is less than a given cut value set in the header (m_jet_vtx_matchRadius, currently 0.4) the vertex and jet are tentatively matched. A map is made where the keys are vertices and the values are vectors of tentatively matched jet - ΔR pairs. A second map is created with vertices as keys but where the values are the jet - ΔR pairs with the lowest ΔR value for each vertex. Two additional maps are created with jets as keys and for whom the values are vectors of either TruthVertexContainers or ΔR values. For each matched vertex an element link is created and is placed in the vector of links for the relevant jet, and the same occurs for the ΔR values. Each vertex is decorated as having been matched, as well as the ID and index of the matched jet and the ΔR value between them. Finally each jet is decorated with the vector of vertex links and the vector of ΔR values.

• int *Count = the number of truth vertices matched to the respective jet
• vector *_dR = vector of ΔR values between matched vertices and the respective jet
• vector *_ID = vector of matched truth vertices' IDs
• vector *_index = vector of matched truth vertices' indices
• vector *_[x/y/z/r] = vector of the position information for the matched truth vertices
• vector *nOutP = vector of the number of outgoing particles for each of the matched truth vertices

ΔR Truth (Dark) Jet Matching [MC Only]

The matching is performed in ObjectMatcher::matchTruthJets(jets, matchJets, jet_type, matchJet_type, jet_string)

For each jet in the function iterates over all the jets in matchJets, skipping any matchJet which has already been matched. The ΔR value between the jet and matchJet is calculated and the two are matched if the ΔR value is less than a given cut set in the header (m_jet_matchRadius, currently 0.1).The matchJet is give the decor of having been matched, the ID and index of the jet it was matched to as well as the ΔR between them. Similarly the jet will be decorated as having a match, will have the ID and index of the matched matchJet as well as the ΔR value between them. Finally a link is made of the matchJet and it is added as decor to the jet it was matched to.

The following two variable names are for the matchJet jets [reco only]

• uint8_t *_isTruthMatched
• int *_truthMatch_ID
• int *_truthMatch_index
• float *_truthMatch_dR * Represents the fact that this jet has been matched to a truth jet

[reco and truthJet only]

• uint8_t *_isDarkMatched
• int *_darkMatchID
• int *_truthMatch_index
• float *_darkMatch_dR
  • Represents the fact that this jet has been matched to a dark jet

The following two variable names are for the jets and not the matchJets [darkJet only]

• uint8_t *_isMatchedToTruth
• int *_matchedTruthID
• int *_matchedTruthIndex
• float *_matchedTruthDR
  • Represents that this jet is matched to a truth jet

[truth only]

• uint8_t *_isMatchedTo[EMTopo/PFlow]
• int *_matched[EMTopo/PFlow]ID
• int *_matched[EMTopo/PFlow]Index
• float *_matched[EMTopo/PFlow]DR
  • Represents that this jet is matched to a reconstructed jet from either EMTopo or PFlow

-- JeremieHarmondLepageBourbonnais - 2020-05-15