fastjet::CASubJetTagger Class Reference

clean (almost parameter-free) tagger searching for the element in the clustering history that maximises a chosen distance More...

#include <CASubJetTagger.hh>

Inheritance diagram for fastjet::CASubJetTagger:

Collaboration diagram for fastjet::CASubJetTagger:

List of all members.

Classes
class	JetAux
	class that contains the result internally More...
Public Types
enum	ScaleChoice {   kt2_distance, jade_distance, jade2_distance, plain_distance,   mass_drop_distance, dot_product_distance }
	the available choices of auxiliary scale with respect to which to order the splittings
typedef CASubJetStructure	StructureType
	the type of Structure returned
Public Member Functions
	CASubJetTagger (ScaleChoice scale_choice=jade_distance, double z_threshold=0.1)
	just constructs
void	set_dr_min (double drmin)
	sets a minimum delta R below which spliting will be ignored (only relevant if set prior to calling run())
virtual std::string	description () const
	the tagger's description
void	set_absolute_z_cut (bool abs_z_cut=true)
	If (abs_z_cut) is set to false (the default) then for a splitting to be considered, each subjet must satisfy.
virtual PseudoJet	result (const fastjet::PseudoJet &jet) const
	run the tagger on the given cs/jet
Protected Member Functions
void	_recurse_through_jet (const PseudoJet &current_jet, JetAux &aux_max, const PseudoJet &original_jet) const
Protected Attributes
ScaleChoice	_scale_choice
double	_z_threshold
double	_dr2_min
bool	_absolute_z_cut
Static Protected Attributes
static LimitedWarning	_non_ca_warnings

---

Detailed Description

clean (almost parameter-free) tagger searching for the element in the clustering history that maximises a chosen distance

class to help us get a clean (almost parameter-free) handle on substructure inside a C/A jet. It follows the logic described in arXiv:0906.0728 (and is inspired by the original Cambridge algorithm paper in its use of separate angular and dimensionful distances), but provides some extra flexibility.

It searches for all splittings that pass a symmetry cut (zcut) and then selects the one with the largest auxiliary scale choice (e.g. jade distance of the splitting, kt distance of the splitting, etc.)

By default, the zcut is calculated from the fraction of the child pt carried by the parent jet. If one calls set_absolute_z_cut the fraction of transverse momentum will be computed wrt the original jet.

original code copyright (C) 2009 by Gavin Salam, released under the GPL.

Options

• the distance choice: options are kt2_distance : usual min(kti^2,ktj^2)DeltaR_{ij}^2 jade_distance : kti . ktj DeltaR_{ij}^2 (LI version of jade) jade2_distance : kti . ktj DeltaR_{ij}^4 (LI version of jade * DR^2) plain_distance : DeltaR_{ij}^2 mass_drop_distance : m_jet - max(m_parent1,m_parent2) dot_product_distance: parent1.parent2 (kt2_distance by default)

• the z cut (0 by default)

• by calling set_absolute_z_cut(), one can ask that the pt fraction if calculated wrt the original jet

• by calling set_dr_min(drmin), one can ask that only the recombinations where the 2 objects are (geometrically) distant by at least drmin are kept in the maximisation.

Input conditions

• the jet must have been obtained from a Cambridge/Aachen cluster sequence

Output/structure

• the element of the cluster sequence maximising the requested distance (and satisfying the zcut) is returned.

• if the original jet has no parents, it will be returned

• the value of the "z" and distance corresponding to that history element are stored and accessible through result.structure_of<CASubJetTagger>().z(); result.structure_of<CASubJetTagger>().distance();

Definition at line 106 of file CASubJetTagger.hh.

---

Member Function Documentation

void fastjet::CASubJetTagger::set_absolute_z_cut

(

bool

abs_z_cut = true

)

[inline]

If (abs_z_cut) is set to false (the default) then for a splitting to be considered, each subjet must satisfy.

p_{t,sub} > z_threshold * p_{t,parent}

whereas if it is set to true, then each subject must satisfy

p_{t,sub} > z_threshold * p_{t,original-jet}

where parent is the immediate parent of the splitting, and original jet is the one supplied to the run() function.

Only relevant is called prior to run().

Definition at line 146 of file CASubJetTagger.hh.

{_absolute_z_cut = abs_z_cut;}

void fastjet::CASubJetTagger::_recurse_through_jet	(	const PseudoJet &	current_jet,
		JetAux &	aux,
		const PseudoJet &	original_jet
	)		const [inline, protected]

---------------------------------------------------------------------- work through the jet, establishing a distance at each branching

make sure the objects are not _too_ close together

Definition at line 103 of file CASubJetTagger.cc.

References fastjet::PseudoJet::has_parents(), fastjet::PseudoJet::kt_distance(), fastjet::PseudoJet::m(), fastjet::PseudoJet::perp(), fastjet::PseudoJet::perp2(), and fastjet::PseudoJet::squared_distance().

                                                                                                                                {

  fastjet::PseudoJet parent1, parent2;
  if (! jet.has_parents(parent1, parent2)) return;

  /// make sure the objects are not _too_ close together
  if (parent1.squared_distance(parent2) < _dr2_min) return;

  // distance
  double dist=0.0;
  switch (_scale_choice) {
  case kt2_distance:
    // a standard (LI) kt distance
    dist = parent1.kt_distance(parent2);
    break;
  case jade_distance:
    // something a bit like a mass: pti ptj Delta R_ij^2
    dist = parent1.perp()*parent2.perp()*parent1.squared_distance(parent2);
    break;
  case jade2_distance:
    // something a bit like a mass*deltaR^2: pti ptj Delta R_ij^4
    dist = parent1.perp()*parent2.perp()*pow(parent1.squared_distance(parent2),2);
    break;
  case plain_distance:
    // Delta R_ij^2
    dist = parent1.squared_distance(parent2);
    break;
  case mass_drop_distance:
    // Delta R_ij^2
    dist = jet.m() - std::max(parent1.m(),parent2.m());
    break;
  case dot_product_distance:
    // parent1 . parent2 
    // ( = jet.m2() - parent1.m2() - parent2.m() in a 
    // 4-vector recombination scheme) 
    dist = dot_product(parent1, parent2);
    break;
  default:
    throw fastjet::Error("unrecognized scale choice");
  }

  // check the z cut
  bool zcut1 = true;
  bool zcut2 = true;
  double z2 = 0.0;

  // not very efficient -- sort out later
  if (parent1.perp2() < parent2.perp2()) std::swap(parent1,parent2);

  if (_absolute_z_cut) {
    z2    = parent2.perp() / original_jet.perp();
    zcut1 = parent1.perp() / original_jet.perp() >= _z_threshold;
  } else {
    z2    = parent2.perp()/(parent1.perp()+parent2.perp());
  }
  zcut2 = z2 >= _z_threshold;

  if (zcut1 && zcut2){
    if (dist > aux.aux_distance){
      aux.jet          = jet;
      aux.aux_distance = dist;
      aux.delta_r      = sqrt(parent1.squared_distance(parent2));
      aux.z            = z2; // the softest
    }
  }    

  if (zcut1) _recurse_through_jet(parent1, aux, original_jet);
  if (zcut2) _recurse_through_jet(parent2, aux, original_jet);
}

---

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

• tools/fastjet/tools/CASubJetTagger.hh
• tools/CASubJetTagger.cc