fastjet::NSubjettinessTagger Class Reference

Class that helps perform 2-pronged boosted tagging using N-subjettiness. More...

#include <NSubjettinessTagger.hh>

Inheritance diagram for fastjet::NSubjettinessTagger:

Collaboration diagram for fastjet::NSubjettinessTagger:

List of all members.

Public Types
typedef NSubjettinessStructure	StructureType
	the type of Structure returned
Public Member Functions
	NSubjettinessTagger (const JetDefinition subjet_def, const double tau2cut=0.08, const double costhetascut=0.8, const bool use_exclusive=false)
	ctor with arguments (see the class description above)
virtual std::string	description () const
	tagger description
virtual PseudoJet	result (const PseudoJet &jet) const
	action on a single jet
Protected Attributes
JetDefinition	_subjet_def
double	_t2cut
double	_costscut
bool	_use_exclusive

---

Detailed Description

Class that helps perform 2-pronged boosted tagging using N-subjettiness.

This is the implementation of the N-Subjettiness tagger introduced by Ji-Hun Kim in arXiv:1011.1493.

To tag a fat jet, we proceed as follows:

• boost its constituents into the rest frame of the jet

• recluster them using another jet definition (the original choice was SISCone in spherical coordinates with R=0.6 and f=0.75.

• keep the 2 most energetic subjets ( ) and compute the 2-subjettiness

  

  where the sum runs over the constituents of the jet.

• require [0.08 by default]

• impose that (in the rest frame of the fat jet), the angles between the 2 most energetic subjets and the boost axis are both large enough: [0.8 by default]

Note that in the original version, the jets are reconstructed using SISCone with R=0.8 and f=0.75. Also, b-tagging was imposed on the 2 subjets found in the tagging procedure.

Options

The constructor has the following arguments:

• The first argument is the jet definition to be used to recluster the constituents of the jet to be filtered (in the rest frame of the tagged jet).
• The second argument is the cut on tau_2 [0.08 by default]
• The 3rd argument is the cut on cos(theta_s) [0.8 by default]
• If the 4th argument is true, 2 exclusive rest-frame jets will be considered in place of the 2 most energetic inclusive jets

Input conditions

• the original jet must have constituents

Output/structure

• the 2 subjets are kept as pieces if some substructure is found, otherwise a single 0-momentum piece
• the tau2 and maximal cos(theta_s) values computed during the tagging

Definition at line 102 of file NSubjettinessTagger.hh.

---

Member Function Documentation

PseudoJet NSubjettinessTagger::result

(

const PseudoJet &

jet

)

const [virtual]

action on a single jet

impose the cut on cos(theta_s)

Implements fastjet::Transformer.

Definition at line 55 of file NSubjettinessTagger.cc.

References fastjet::PseudoJet::constituents(), fastjet::ClusterSequence::delete_self_when_unused(), fastjet::ClusterSequence::exclusive_jets(), fastjet::PseudoJet::has_constituents(), fastjet::ClusterSequence::history(), fastjet::ClusterSequence::inclusive_jets(), fastjet::ClusterSequence::jets(), fastjet::PseudoJet::m2(), fastjet::PseudoJet::modp2(), fastjet::sorted_by_E(), fastjet::PseudoJet::structure_non_const_ptr(), and fastjet::ClusterSequence::transfer_from_sequence().

                                                                {
  // make sure that the jet has constituents
  if (!jet.has_constituents())
    throw("The jet you try to tag needs to have accessible constituents");
   
  // get the constituents and boost them into the rest frame of the jet
  vector<PseudoJet> rest_input = jet.constituents();
  for (unsigned int i=0; i<rest_input.size(); i++)
    rest_input[i].unboost(jet);

  ClusterSequence cs_rest(rest_input, _subjet_def);
  vector<PseudoJet> subjets = (_use_exclusive)
    ? cs_rest.exclusive_jets(2)
    : sorted_by_E(cs_rest.inclusive_jets());

  // impose the cuts in the rest-frame
  if (subjets.size()<2) return PseudoJet();

  const PseudoJet &j0 = subjets[0];
  const PseudoJet &j1 = subjets[1];

  /// impose the cut on cos(theta_s)
  double ct0 = (j0.px()*jet.px() + j0.py()*jet.py() + j0.pz()*jet.pz())
    /sqrt(j0.modp2()*jet.modp2());
  double ct1 = (j1.px()*jet.px() + j1.py()*jet.py() + j1.pz()*jet.pz())
    /sqrt(j1.modp2()*jet.modp2());
  if ((ct0 > _costscut) || (ct1 > _costscut)) return PseudoJet();
  
  // ccompute the 2-subjettiness and impose the coresponding cut
  double tau2 = 0.0;
  for (unsigned int i=0; i<rest_input.size(); i++)
    tau2 += min(dot_product(rest_input[i], j0), 
                dot_product(rest_input[i], j1));

  tau2 *= (2.0/jet.m2());

  if (tau2 > _t2cut) return PseudoJet();

  // We have a positive tag, 
  //  - boost everything back into the lab frame
  //  - record the info in the interface
  // Note that in order to point to the correct Clustersequence, the
  // subjets must be taken from the boosted one. We extract that
  // through the history index of the rest-frame subjets
  ClusterSequence * cs_structure = new ClusterSequence();
  Boost boost(jet);
  cs_structure->transfer_from_sequence(cs_rest, &boost);
  PseudoJet subjet_lab1 = cs_structure->jets()[cs_rest.history()[subjets[0].cluster_hist_index()].jetp_index];
  PseudoJet subjet_lab2 = cs_structure->jets()[cs_rest.history()[subjets[0].cluster_hist_index()].jetp_index];
    
  PseudoJet result = join<StructureType>(subjet_lab1,subjet_lab2);
  StructureType * s = (StructureType *) result.structure_non_const_ptr();
  s->_tau2 = tau2;
  s->_costhetas = max(ct0, ct1);

  // keep the rest-frame CS alive
  cs_structure->delete_self_when_unused();

  return result;
}

---

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

• tools/fastjet/tools/NSubjettinessTagger.hh
• tools/NSubjettinessTagger.cc