FastJet  3.1.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
JHTopTagger.hh
1 #ifndef __FASTJET_JH_TOP_TAGGER_HH__
2 #define __FASTJET_JH_TOP_TAGGER_HH__
3 
4 //FJSTARTHEADER
5 // $Id: JHTopTagger.hh 3433 2014-07-23 08:17:03Z salam $
6 //
7 // Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
8 //
9 //----------------------------------------------------------------------
10 // This file is part of FastJet.
11 //
12 // FastJet is free software; you can redistribute it and/or modify
13 // it under the terms of the GNU General Public License as published by
14 // the Free Software Foundation; either version 2 of the License, or
15 // (at your option) any later version.
16 //
17 // The algorithms that underlie FastJet have required considerable
18 // development. They are described in the original FastJet paper,
19 // hep-ph/0512210 and in the manual, arXiv:1111.6097. If you use
20 // FastJet as part of work towards a scientific publication, please
21 // quote the version you use and include a citation to the manual and
22 // optionally also to hep-ph/0512210.
23 //
24 // FastJet is distributed in the hope that it will be useful,
25 // but WITHOUT ANY WARRANTY; without even the implied warranty of
26 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 // GNU General Public License for more details.
28 //
29 // You should have received a copy of the GNU General Public License
30 // along with FastJet. If not, see <http://www.gnu.org/licenses/>.
31 //----------------------------------------------------------------------
32 //FJENDHEADER
33 
34 
35 #include <fastjet/tools/TopTaggerBase.hh>
36 #include <fastjet/CompositeJetStructure.hh>
37 #include <fastjet/LimitedWarning.hh>
38 
39 FASTJET_BEGIN_NAMESPACE
40 
41 class JHTopTagger;
42 class JHTopTaggerStructure;
43 
44 //----------------------------------------------------------------------
45 /// @ingroup tools_taggers
46 /// \class JHTopTagger
47 /// Class that helps perform boosted top tagging using the "Johns Hopkins"
48 /// method from arXiv:0806.0848 (Kaplan, Rehermann, Schwartz
49 /// and Tweedie)
50 ///
51 ///The tagger proceeds as follows:
52 /// - start from a jet J obtained with the Cambridge/Aachen algorithm
53 /// - undo the last iteration j -> j_1,j_2 (with pt_1>pt_2) until the
54 /// two subjets satisfy pt_1 > delta_p pt_J (with pt_J the pt of
55 /// the original jet) and |y_1 - y_2| + |phi_1 - phi_2| > delta_r.
56 /// - if one of these criteria is not satisfied, carry on the
57 /// procedure with j_1 (discarding j_2)
58 /// - for each of the subjets found, repeat the procedure. If some
59 /// new substructure is found, keep these 2 new subjets, otherwise
60 /// keep the original subjet (found during the first iteration)
61 /// - at this stage, one has at most 4 subjets. If one has less than
62 /// 3, the tagger has failed.
63 /// - reconstruct the W from the 2 subjets with a mass closest to the
64 /// W mass
65 /// - impose that the W helicity angle be less than a threshold
66 /// cos_theta_W_max.
67 ///
68 /// \section input Input conditions
69 ///
70 /// - the original jet must have an associated (and valid)
71 /// ClusterSequence
72 /// - the tagger is designed to work with jets formed by the
73 /// Cambridge/Aachen (C/A) algorithm; if a non-C/A jet is passed to
74 /// the tagger, a warning will be issued
75 ///
76 /// \section Example
77 ///
78 /// A JHTopTagger can be used as follows:
79 ///
80 /// \code
81 /// double delta_p = 0.10; // subjets must carry at least this fraction of the original jet's p_t
82 /// double delta_r = 0.19; // subjets must be separated by at least this Manhattan distance
83 /// double cos_theta_W_max = 0.7; // the maximal allowed value of the W helicity angle
84 /// JHTopTagger top_tagger(delta_p, delta_r, cos_theta_W_max);
85 /// // indicate the acceptable range of top, W masses (default: no limits)
86 /// top_tagger.set_top_selector(SelectorMassRange(150,200));
87 /// top_tagger.set_W_selector (SelectorMassRange( 65, 95));
88 /// // now try and tag a jet
89 /// PseudoJet top_candidate = top_tagger(jet); // jet should come from a Cambridge/Aachen clustering
90 /// if (top_candidate != 0) { // successful tagging
91 /// double top_mass = top_candidate.m();
92 /// double W_mass = top_candidate.structure_of<JHTopTagger>().W().m();
93 /// }
94 /// \endcode
95 ///
96 /// The full set of information available from the structure_of<JHTopTagger>()
97 /// call is
98 ///
99 /// - PseudoJet W() : the W subjet of the top candidate
100 /// - PseudoJet non_W(): non-W subjet(s) of the top candidate (i.e. the b)
101 /// - double cos_theta_W(): the W helicity angle
102 /// - PseudoJet W1(): the harder of the two prongs of the W
103 /// - PseudoJet W2(): the softer of the two prongs of the W
104 ///
105 /// The structure of the top_candidate can also be accessed through its
106 /// pieces() function:
107 ///
108 /// - top_candidate.pieces()[0]: W
109 /// - top_candidate.pieces()[1]: non_W
110 ///
111 /// The W itself has two pieces (corresponding to W1, W2).
112 ///
113 /// The existence of the first two of the structural calls (W(),
114 /// non_W()) and the fact that the top is made of two pieces (W,
115 /// non_W) are features that should be common to all taggers derived
116 /// from TopTaggerBase.
117 ///
118 /// See also \subpage Example13 for a full usage example.
119 ///
120 class JHTopTagger : public TopTaggerBase {
121 public:
122  /// default ctor
123  /// The parameters are the following:
124  /// \param delta_p fractional pt cut imposed on the subjets
125  /// (computed as a fraction of the original jet)
126  /// \param delta_r minimal distance between 2 subjets
127  /// (computed as |y1-y2|+|phi1-phi2|)
128  /// \param cos_theta_W_max the maximal value for the polarisation
129  /// angle of the W
130  /// \param mW the W mass
131  ///
132  /// The default values of all these parameters are taken from
133  /// arXiv:0806:0848
134  JHTopTagger(const double delta_p=0.10, const double delta_r=0.19,
135  double cos_theta_W_max=0.7, double mW=80.4)
136  : _delta_p(delta_p), _delta_r(delta_r),
137  _cos_theta_W_max(cos_theta_W_max), _mW(mW){};
138 
139  /// returns a textual description of the tagger
140  virtual std::string description() const;
141 
142  /// runs the tagger on the given jet and
143  /// returns the tagged PseudoJet if successful, or a PseudoJet==0 otherwise
144  /// (standard access is through operator()).
145  /// \param jet the PseudoJet to tag
146  virtual PseudoJet result(const PseudoJet & jet) const;
147 
148  // the type of the associated structure
149  typedef JHTopTaggerStructure StructureType;
150 
151 protected:
152  /// runs the Johns Hopkins decomposition procedure
153  std::vector<PseudoJet> _split_once(const PseudoJet & jet_to_split,
154  const PseudoJet & reference_jet) const;
155 
156  double _delta_p, _delta_r, _cos_theta_W_max, _mW;
157  static LimitedWarning _warnings_nonca;
158 };
159 
160 
161 //------------------------------------------------------------------------
162 /// @ingroup tools_taggers
163 /// \class JHTopTaggerStructure
164 /// the structure returned by the JHTopTagger transformer.
165 ///
166 /// See the JHTopTagger class description for the details of what
167 /// is inside this structure
168 ///
170 public:
171  /// ctor with pieces initialisation
172  JHTopTaggerStructure(std::vector<PseudoJet> pieces_in,
173  const JetDefinition::Recombiner *recombiner = 0) :
174  CompositeJetStructure(pieces_in, recombiner), _cos_theta_w(0.0){}
175 
176  /// returns the W subjet
177  inline const PseudoJet & W() const{
178  return _pieces[0];
179  }
180 
181  /// returns the first W subjet (the harder)
182  inline PseudoJet W1() const{
183  assert(W().pieces().size()>0);
184  return W().pieces()[0];
185  }
186 
187  /// returns the second W subjet
188  inline PseudoJet W2() const{
189  assert(W().pieces().size()>1);
190  return W().pieces()[1];
191  }
192 
193  /// returns the non-W subjet
194  /// It will have 1 or 2 pieces depending on whether the tagger has
195  /// found 3 or 4 pieces
196  inline const PseudoJet & non_W() const{
197  return _pieces[1];
198  }
199 
200  /// returns the W helicity angle
201  inline double cos_theta_W() const {return _cos_theta_w;}
202 
203 // /// returns the original jet (before tagging)
204 // const PseudoJet & original() const {return _original_jet;}
205 
206 
207 protected:
208  double _cos_theta_w; ///< the W helicity angle
209  //PseudoJet _W; ///< the tagged W
210  //PseudoJet _non_W; ///< the remaining pieces
211 // PseudoJet _original_jet; ///< the original jet (before tagging)
212 
213  // allow the tagger to set these
214  friend class JHTopTagger;
215 };
216 
217 
218 
219 FASTJET_END_NAMESPACE
220 
221 #endif // __FASTJET_JH_TOP_TAGGER_HH__
222 
PseudoJet W2() const
returns the second W subjet
Definition: JHTopTagger.hh:188
double _cos_theta_w
the W helicity angle
Definition: JHTopTagger.hh:208
JHTopTaggerStructure(std::vector< PseudoJet > pieces_in, const JetDefinition::Recombiner *recombiner=0)
ctor with pieces initialisation
Definition: JHTopTagger.hh:172
The structure for a jet made of pieces.
JHTopTagger(const double delta_p=0.10, const double delta_r=0.19, double cos_theta_W_max=0.7, double mW=80.4)
default ctor The parameters are the following:
Definition: JHTopTagger.hh:134
A base class that provides a common interface for top taggers that are able to return a W (in additio...
class to provide facilities for giving warnings up to some maximum number of times and to provide glo...
const PseudoJet & non_W() const
returns the non-W subjet It will have 1 or 2 pieces depending on whether the tagger has found 3 or 4 ...
Definition: JHTopTagger.hh:196
Class that helps perform boosted top tagging using the "Johns Hopkins" method from arXiv:0806...
Definition: JHTopTagger.hh:120
const PseudoJet & W() const
returns the W subjet
Definition: JHTopTagger.hh:177
double cos_theta_W() const
returns the W helicity angle
Definition: JHTopTagger.hh:201
An abstract base class that will provide the recombination scheme facilities and/or allow a user to e...
class that specifies the structure common to all top taggers
Class to contain pseudojets, including minimal information of use to jet-clustering routines...
Definition: PseudoJet.hh:67
the structure returned by the JHTopTagger transformer.
Definition: JHTopTagger.hh:169
PseudoJet W1() const
returns the first W subjet (the harder)
Definition: JHTopTagger.hh:182