fastjet::MassDropTagger Class Reference

Class that helps perform 2-pronged boosted tagging using the "mass-drop" technique. More...

#include <MassDropTagger.hh>

Inheritance diagram for fastjet::MassDropTagger:

Collaboration diagram for fastjet::MassDropTagger:

List of all members.

Public Types
typedef MassDropStructure	StructureType
	the type of the associated structure
Public Member Functions
	MassDropTagger (const double mu=0.67, const double ycut=0.09)
	default ctor
virtual std::string	description () const
	description of the tagger
virtual PseudoJet	result (const PseudoJet &jet) const
	the tagging itself
Protected Attributes
double	_mu
double	_ycut

---

Detailed Description

Class that helps perform 2-pronged boosted tagging using the "mass-drop" technique.

This implements the boosted Higgs tagger introduced by Jonathan Butterworth, Adam Davison, Mathieu Rubin and Gavin Salam in arXiv:0802.2470.

The tagger proceeds as follows:

0. start from a jet obtained from with the Cambridge/Aachen algorithm

1. undo the last step of the clustering step j -> j1 + j2 (label them such as j1 is the most massive).

2. if there is a mass drop, i.e. m_j1/m_j < mu_cut, and the splitting is sufficiently symmetric, , keep j as the result of the tagger (with j1 and j2 its 2 subjets)

3. otherwise, redefine j to be equal to j1 and return to step 1.

Note that in the original proposal, j1 and j2 were both required to be b-tagged and a filter (with Rfilt=min(0.3,Rbb/2) and n_filt=3) was applied to j to obtain the final "Higgs candidate". This filtering technique can always be done by defining a FunctionOfPseudoJet to compute dynamically Rfilt and then use the Filter RfiltDyn rfilt; Filter final_filter(&rfilt, SelectorNHardest(3)); See the filter example to see explicitly how this can be done.

Options

The constructor has the following arguments:

• The first argument is minimal mass drop required (mu_cut) [0.67 by default]
• The second argument is asymmetry cut (y_cut) [0.09 by default]

Input conditions

• one must be able to succesively "uncluster" the original jet using "has_parents"

Output/structure

• the 2 subjets are kept as pieces if some substructure is found, otherwise a single 0-momentum piece is returned
• the 'mu' and 'y' values corresponding to the unclustering step that passed the tagger's cuts

Definition at line 98 of file MassDropTagger.hh.

---

Member Function Documentation

PseudoJet fastjet::MassDropTagger::result

(

const PseudoJet &

jet

)

const [virtual]

the tagging itself

Parameters:

jet	the PseudoJet to tag

Implements fastjet::Transformer.

Definition at line 54 of file MassDropTagger.cc.

References fastjet::PseudoJet::associated_cluster_sequence(), fastjet::PseudoJet::has_parents(), fastjet::ClusterSequence::jet_def(), fastjet::PseudoJet::kt_distance(), fastjet::PseudoJet::m(), fastjet::PseudoJet::m2(), fastjet::JetDefinition::recombiner(), and fastjet::PseudoJet::structure_non_const_ptr().

                                                           {
  PseudoJet j = jet;
  PseudoJet j1, j2;
  bool had_parents;

  // we just ask that we can "walk" in the cluster sequence.
  // appropriate errors will be thrown automatically if this is not
  // the case
  while ((had_parents = j.has_parents(j1,j2))) {
    // make parent1 the more massive jet
    if (j1.m() < j2.m()) std::swap(j1,j2);

    // if we pass the conditions on the mass drop and its degree of
    // asymmetry (kt_dist/m^2 > rtycut [where kt_dist/m^2 \sim
    // z/(1-z)), then we've found something interesting, so exit the
    // loop
    if ( (j1.m() < _mu*j.m()) && (j1.kt_distance(j2) > _ycut*j.m2()) )
      break;
    else
      j = j1;
  }
    
  if (!had_parents)
    // no Higgs found, return an empty PseudoJet
    return PseudoJet();

  // create the result and its structure
  const JetDefinition::Recombiner *rec
    = jet.associated_cluster_sequence()->jet_def().recombiner();
  PseudoJet result = join<MassDropStructure>(j1,j2,*rec);
  MassDropStructure * s = (MassDropStructure *) result.structure_non_const_ptr();
  s->_mu = (j.m()!=0.0) ? j1.m()/j.m() : 0.0;
  s->_y  = (j1.m2()!=0.0) ? j1.kt_distance(j2)/j.m2() : 0.0;

  return result;
}

---

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

• tools/fastjet/tools/MassDropTagger.hh
• tools/MassDropTagger.cc