FastJet  3.3.3
JetDefinition.hh
1 #ifndef __FASTJET_JETDEFINITION_HH__
2 #define __FASTJET_JETDEFINITION_HH__
3 
4 //FJSTARTHEADER
5 // $Id: JetDefinition.hh 4420 2019-11-29 09:28:20Z soyez $
6 //
7 // Copyright (c) 2005-2019, 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 #include<cassert>
35 #include "fastjet/internal/numconsts.hh"
36 #include "fastjet/PseudoJet.hh"
37 #include "fastjet/internal/deprecated.hh"
38 #include<string>
39 #include<memory>
40 
41 FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh
42 
43 /// return a string containing information about the release
44 // NB: (implemented in ClusterSequence.cc but defined here because
45 // this is a visible location)
46 std::string fastjet_version_string();
47 
48 //======================================================================
49 /// the various options for the algorithmic strategy to adopt in
50 /// clustering events with kt and cambridge style algorithms.
51 enum Strategy {
52  /// Like N2MHTLazy9 in a number of respects, but does not calculate
53  /// ghost-ghost distances and so does not carry out ghost-ghost
54  /// recombination.
55  ///
56  /// If you want active ghosted areas, then this is only suitable for
57  /// use with the anti-kt algorithm (or genkt with negative p), and
58  /// does not produce any pure ghost jets. If used with active areas
59  /// with Kt or Cam algorithms it will actually produce a passive
60  /// area.
61  ///
62  /// Particles are deemed to be ghosts if their pt is below a
63  /// threshold (currently 1e-50, hard coded as ghost_limit in
64  /// LazyTiling9SeparateGhosts).
65  ///
66  /// Currently for events with a couple of thousand normal particles
67  /// and O(10k) ghosts, this can be quicker than N2MHTLazy9, which
68  /// would otherwise be the best strategy.
69  ///
70  /// New in FJ3.1
72  /// only looks into a neighbouring tile for a particle's nearest
73  /// neighbour (NN) if that particle's in-tile NN is further than the
74  /// distance to the edge of the neighbouring tile. Uses tiles of
75  /// size R and a 3x3 tile grid around the particle.
76  /// New in FJ3.1
77  N2MHTLazy9 = -7,
78  /// Similar to N2MHTLazy9, but uses tiles of size R/2 and a 5x5 tile
79  /// grid around the particle.
80  /// New in FJ3.1
81  N2MHTLazy25 = -6,
82  /// Like to N2MHTLazy9 but uses slightly different optimizations,
83  /// e.g. for calculations of distance to nearest tile; as of
84  /// 2014-07-18 it is slightly slower and not recommended for
85  /// production use. To considered deprecated.
86  /// New in FJ3.1
88  /// faster that N2Tiled above about 500 particles; differs from it
89  /// by retainig the di(closest j) distances in a MinHeap (sort of
90  /// priority queue) rather than a simple vector.
92  /// fastest from about 50..500
93  N2Tiled = -3,
94  /// legacy
95  N2PoorTiled = -2,
96  /// fastest below 50
97  N2Plain = -1,
98  /// worse even than the usual N^3 algorithms
99  N3Dumb = 0,
100  /// automatic selection of the best (based on N), including
101  /// the LazyTiled strategies that are new to FJ3.1
102  Best = 1,
103  /// best of the NlnN variants -- best overall for N>10^4.
104  /// (Does not work for R>=2pi)
105  NlnN = 2,
106  /// legacy N ln N using 3pi coverage of cylinder.
107  /// (Does not work for R>=2pi)
108  NlnN3pi = 3,
109  /// legacy N ln N using 4pi coverage of cylinder
110  NlnN4pi = 4,
111  /// Chan's closest pair method (in a variant with 4pi coverage),
112  /// for use exclusively with the Cambridge algorithm.
113  /// (Does not work for R>=2pi)
115  /// Chan's closest pair method (in a variant with 2pi+2R coverage),
116  /// for use exclusively with the Cambridge algorithm.
117  /// (Does not work for R>=2pi)
119  /// Chan's closest pair method (in a variant with 2pi+minimal extra
120  /// variant), for use exclusively with the Cambridge algorithm.
121  /// (Does not work for R>=2pi)
122  NlnNCam = 12, // 2piMultD
123  /// the automatic strategy choice that was being made in FJ 3.0
124  /// (restricted to strategies that were present in FJ 3.0)
125  BestFJ30 = 21,
126  /// the plugin has been used...
128 };
129 
130 
131 //======================================================================
132 /// \enum JetAlgorithm
133 /// the various families of jet-clustering algorithm
134 //
135 // [Remember to update the "is_spherical()" routine if any further
136 // spherical algorithms are added to the list below]
138  /// the longitudinally invariant kt algorithm
140  /// the longitudinally invariant variant of the cambridge algorithm
141  /// (aka Aachen algoithm).
143  /// like the k_t but with distance measures
144  /// dij = min(1/kti^2,1/ktj^2) Delta R_{ij}^2 / R^2
145  /// diB = 1/kti^2
147  /// like the k_t but with distance measures
148  /// dij = min(kti^{2p},ktj^{2p}) Delta R_{ij}^2 / R^2
149  /// diB = 1/kti^{2p}
150  /// where p = extra_param()
152  /// a version of cambridge with a special distance measure for
153  /// particles whose pt is < extra_param(); this is not usually
154  /// intended for end users, but is instead automatically selected
155  /// when requesting a passive Cambridge area.
157  /// a version of genkt with a special distance measure for particles
158  /// whose pt is < extra_param() [relevant for passive areas when p<=0]
159  /// ***** NB: THERE IS CURRENTLY NO IMPLEMENTATION FOR THIS ALG *******
161  //.................................................................
162  /// the e+e- kt algorithm
164  /// the e+e- genkt algorithm (R > 2 and p=1 gives ee_kt)
166  //.................................................................
167  /// any plugin algorithm supplied by the user
169  //.................................................................
170  /// the value for the jet algorithm in a JetDefinition for which
171  /// no algorithm has yet been defined
173 };
174 
175 /// make standard Les Houches nomenclature JetAlgorithm (algorithm is general
176 /// recipe without the parameters) backward-compatible with old JetFinder
178 
179 /// provide other possible names for the Cambridge/Aachen algorithm
181 const JetAlgorithm cambridge_aachen_algorithm = cambridge_algorithm;
182 
183 //======================================================================
184 /// The various recombination schemes
185 ///
186 /// Note that the schemes that recombine with non-linear weighting of
187 /// the directions (e.g. pt2, winner-takes-all) are collinear safe
188 /// only for algorithms with a suitable ordering of the
189 /// recombinations: orderings in which, for particles of comparable
190 /// energies, small-angle clusterings take place before large-angle
191 /// clusterings. This property is satisfied by all gen-kt algorithms.
192 ///
194  /// summing the 4-momenta
196  /// pt weighted recombination of y,phi (and summing of pt's)
197  /// with preprocessing to make things massless by rescaling E=|\vec p|
199  /// pt^2 weighted recombination of y,phi (and summing of pt's)
200  /// with preprocessing to make things massless by rescaling E=|\vec p|
202  /// pt weighted recombination of y,phi (and summing of pt's)
203  /// with preprocessing to make things massless by rescaling |\vec p|->=E
205  /// pt^2 weighted recombination of y,phi (and summing of pt's)
206  /// with preprocessing to make things massless by rescaling |\vec p|->=E
208  /// pt weighted recombination of y,phi (and summing of pt's), with
209  /// no preprocessing
211  /// pt^2 weighted recombination of y,phi (and summing of pt's)
212  /// no preprocessing
214  /// pt-based Winner-Takes-All (WTA) recombination: the
215  /// result of the recombination has the rapidity, azimuth and mass
216  /// of the PseudoJet with the larger pt, and a pt equal to the
217  /// sum of the two pt's
219  /// mod-p-based Winner-Takes-All (WTA) recombination: the result of
220  /// the recombination gets the 3-vector direction and mass of the
221  /// PseudoJet with the larger |3-momentum| (modp), and a
222  /// |3-momentum| equal to the scalar sum of the two |3-momenta|.
224  // Energy-ordering can lead to dangerous situations with particles at
225  // rest. We instead implement the WTA_modp_scheme
226  //
227  // // energy-based Winner-Takes-All (WTA) recombination: the result of
228  // // the recombination gets the 3-vector direction and mass of the
229  // // PseudoJet with the larger energy, and an energy equal to the
230  // // to the sum of the two energies
231  // WTA_E_scheme=8,
232  /// for the user's external scheme
234 };
235 
236 
237 
238 // forward declaration, needed in order to specify interface for the
239 // plugin.
240 class ClusterSequence;
241 
242 
243 
244 
245 //======================================================================
246 /// @ingroup basic_classes
247 /// \class JetDefinition
248 /// class that is intended to hold a full definition of the jet
249 /// clusterer
251 
252 public:
253 
254  /// forward declaration of a class that allows the user to introduce
255  /// their own plugin
256  class Plugin;
257 
258  // forward declaration of a class that will provide the
259  // recombination scheme facilities and/or allow a user to
260  // extend these facilities
261  class Recombiner;
262 
263 
264  /// constructor with alternative ordering or arguments -- note that
265  /// we have not provided a default jet finder, to avoid ambiguous
266  /// JetDefinition() constructor.
267  JetDefinition(JetAlgorithm jet_algorithm_in,
268  double R_in,
269  RecombinationScheme recomb_scheme_in = E_scheme,
270  Strategy strategy_in = Best) {
271  *this = JetDefinition(jet_algorithm_in, R_in, recomb_scheme_in, strategy_in, 1);
272  }
273 
274  /// constructor for algorithms that have no free parameters
275  /// (e.g. ee_kt_algorithm)
276  JetDefinition(JetAlgorithm jet_algorithm_in,
277  RecombinationScheme recomb_scheme_in = E_scheme,
278  Strategy strategy_in = Best) {
279  double dummyR = 0.0;
280  *this = JetDefinition(jet_algorithm_in, dummyR, recomb_scheme_in, strategy_in, 0);
281  }
282 
283  /// constructor for algorithms that require R + one extra parameter to be set
284  /// (the gen-kt series for example)
285  JetDefinition(JetAlgorithm jet_algorithm_in,
286  double R_in,
287  double xtra_param_in,
288  RecombinationScheme recomb_scheme_in = E_scheme,
289  Strategy strategy_in = Best) {
290  *this = JetDefinition(jet_algorithm_in, R_in, recomb_scheme_in, strategy_in, 2);
291  set_extra_param(xtra_param_in);
292  }
293 
294 
295  /// constructor in a form that allows the user to provide a pointer
296  /// to an external recombiner class (which must remain valid for the
297  /// life of the JetDefinition object).
298  JetDefinition(JetAlgorithm jet_algorithm_in,
299  double R_in,
300  const Recombiner * recombiner_in,
301  Strategy strategy_in = Best) {
302  *this = JetDefinition(jet_algorithm_in, R_in, external_scheme, strategy_in);
303  _recombiner = recombiner_in;
304  }
305 
306 
307  /// constructor for case with 0 parameters (ee_kt_algorithm) and
308  /// and external recombiner
309  JetDefinition(JetAlgorithm jet_algorithm_in,
310  const Recombiner * recombiner_in,
311  Strategy strategy_in = Best) {
312  *this = JetDefinition(jet_algorithm_in, external_scheme, strategy_in);
313  _recombiner = recombiner_in;
314  }
315 
316  /// constructor allowing the extra parameter to be set and a pointer to
317  /// a recombiner
318  JetDefinition(JetAlgorithm jet_algorithm_in,
319  double R_in,
320  double xtra_param_in,
321  const Recombiner * recombiner_in,
322  Strategy strategy_in = Best) {
323  *this = JetDefinition(jet_algorithm_in, R_in, xtra_param_in, external_scheme, strategy_in);
324  _recombiner = recombiner_in;
325  }
326 
327  /// a default constructor which creates a jet definition that is in
328  /// a well-defined internal state, but not actually usable for jet
329  /// clustering.
332  }
333 
334 
335  // /// a default constructor
336  // JetDefinition() {
337  // *this = JetDefinition(kt_algorithm, 1.0);
338  // }
339 
340  /// constructor based on a pointer to a user's plugin; the object
341  /// pointed to must remain valid for the whole duration of existence
342  /// of the JetDefinition and any related ClusterSequences
343  JetDefinition(const Plugin * plugin_in) {
344  _plugin = plugin_in;
345  _strategy = plugin_strategy;
346  _Rparam = _plugin->R();
347  _extra_param = 0.0; // a dummy value to keep static code checkers happy
348  _jet_algorithm = plugin_algorithm;
349  set_recombination_scheme(E_scheme);
350  }
351 
352  /// constructor to fully specify a jet-definition (together with
353  /// information about how algorithically to run it).
354  JetDefinition(JetAlgorithm jet_algorithm_in,
355  double R_in,
356  RecombinationScheme recomb_scheme_in,
357  Strategy strategy_in,
358  int nparameters_in);
359 
360  /// constructor to fully specify a jet-definition (together with
361  /// information about how algorithically to run it).
362  ///
363  /// the ordering of arguments here is old and deprecated (except
364  /// as the common constructor for internal use)
365  FASTJET_DEPRECATED_MSG("This argument ordering is deprecated. Use JetDefinition(alg, R, strategy, scheme[, n_parameters]) instead")
366  JetDefinition(JetAlgorithm jet_algorithm_in,
367  double R_in,
368  Strategy strategy_in,
369  RecombinationScheme recomb_scheme_in = E_scheme,
370  int nparameters_in = 1){
371  (*this) = JetDefinition(jet_algorithm_in,R_in,recomb_scheme_in,strategy_in,nparameters_in);
372  }
373 
374 
375  /// cluster the supplied particles and returns a vector of resulting
376  /// jets, sorted by pt (or energy in the case of spherical,
377  /// i.e. e+e-, algorithms). This routine currently only makes
378  /// sense for "inclusive" type algorithms.
379  template <class L>
380  std::vector<PseudoJet> operator()(const std::vector<L> & particles) const;
381 
382  /// R values larger than max_allowable_R are not allowed.
383  ///
384  /// We use a value of 1000, substantially smaller than
385  /// numeric_limits<double>::max(), to leave room for the convention
386  /// within PseudoJet of setting unphysical (infinite) rapidities to
387  /// +-(MaxRap + abs(pz())), where MaxRap is 10^5.
388  static const double max_allowable_R; //= 1000.0;
389 
390  /// set the recombination scheme to the one provided
391  void set_recombination_scheme(RecombinationScheme);
392 
393  /// set the recombiner class to the one provided
394  ///
395  /// Note that in order to associate to a jet definition a recombiner
396  /// from another jet definition, it is strongly recommended to use
397  /// the set_recombiner(const JetDefinition &) method below. The
398  /// latter correctly handles the situations where the jet definition
399  /// owns the recombiner (i.e. where delete_recombiner_when_unused
400  /// has been called). In such cases, using set_recombiner(const
401  /// Recombiner *) may lead to memory corruption.
402  void set_recombiner(const Recombiner * recomb) {
403  if (_shared_recombiner) _shared_recombiner.reset(recomb);
404  _recombiner = recomb;
405  _default_recombiner = DefaultRecombiner(external_scheme);
406  }
407 
408  /// set the recombiner to be the same as the one of 'other_jet_def'
409  ///
410  /// Note that this is the recommended method to associate to a jet
411  /// definition the recombiner from another jet definition. Compared
412  /// to the set_recombiner(const Recombiner *) above, it correctly
413  /// handles the case where the jet definition owns the recombiner
414  /// (i.e. where delete_recombiner_when_unused has been called)
415  void set_recombiner(const JetDefinition &other_jet_def);
416 
417  /// calling this tells the JetDefinition to handle the deletion of
418  /// the recombiner when it is no longer used. (Should not be called
419  /// if the recombiner was initialised from a JetDef whose recombiner
420  /// was already scheduled to delete itself - memory handling will
421  /// already be automatic across both JetDef's in that case).
422  void delete_recombiner_when_unused();
423 
424  /// return a pointer to the plugin
425  const Plugin * plugin() const {return _plugin;};
426 
427  /// calling this causes the JetDefinition to handle the deletion of the
428  /// plugin when it is no longer used
429  void delete_plugin_when_unused();
430 
431  /// return information about the definition...
432  JetAlgorithm jet_algorithm () const {return _jet_algorithm ;}
433  /// same as above for backward compatibility
434  JetAlgorithm jet_finder () const {return _jet_algorithm ;}
435  double R () const {return _Rparam ;}
436  // a general purpose extra parameter, whose meaning depends on
437  // the algorithm, and may often be unused.
438  double extra_param () const {return _extra_param ;}
439  Strategy strategy () const {return _strategy ;}
440  RecombinationScheme recombination_scheme() const {
441  return _default_recombiner.scheme();}
442 
443  /// (re)set the jet finder
444  void set_jet_algorithm(JetAlgorithm njf) {_jet_algorithm = njf;}
445  /// same as above for backward compatibility
446  void set_jet_finder(JetAlgorithm njf) {_jet_algorithm = njf;}
447  /// (re)set the general purpose extra parameter
448  void set_extra_param(double xtra_param) {_extra_param = xtra_param;}
449 
450  /// returns a pointer to the currently defined recombiner.
451  ///
452  /// Warning: the pointer may be to an internal recombiner (for
453  /// default recombination schemes), in which case if the
454  /// JetDefinition becomes invalid (e.g. is deleted), the pointer
455  /// will then point to an object that no longer exists.
456  ///
457  /// Note also that if you copy a JetDefinition with a default
458  /// recombination scheme, then the two copies will have distinct
459  /// recombiners, and return different recombiner() pointers.
460  const Recombiner * recombiner() const {
461  return _recombiner == 0 ? & _default_recombiner : _recombiner;}
462 
463  /// returns true if the current jet definitions shares the same
464  /// recombiner as the one passed as an argument
465  bool has_same_recombiner(const JetDefinition &other_jd) const;
466 
467  /// returns true if the jet definition involves an algorithm
468  /// intended for use on a spherical geometry (e.g. e+e- algorithms,
469  /// as opposed to most pp algorithms, which use a cylindrical,
470  /// rapidity-phi geometry).
471  bool is_spherical() const;
472 
473  /// return a textual description of the current jet definition
474  std::string description() const;
475 
476  /// returns a description not including the recombiner information
477  std::string description_no_recombiner() const;
478 
479  /// a short textual description of the algorithm jet_alg
480  static std::string algorithm_description(const JetAlgorithm jet_alg);
481 
482  /// the number of parameters associated to a given jet algorithm
483  static unsigned int n_parameters_for_algorithm(const JetAlgorithm jet_alg);
484 
485 public:
486  //======================================================================
487  /// @ingroup advanced_usage
488  /// \class Recombiner
489  /// An abstract base class that will provide the recombination scheme
490  /// facilities and/or allow a user to extend these facilities
491  class Recombiner {
492  public:
493  /// return a textual description of the recombination scheme
494  /// implemented here
495  virtual std::string description() const = 0;
496 
497  /// recombine pa and pb and put result into pab
498  virtual void recombine(const PseudoJet & pa, const PseudoJet & pb,
499  PseudoJet & pab) const = 0;
500 
501  /// routine called to preprocess each input jet (to make all input
502  /// jets compatible with the scheme requirements (e.g. massless).
503  virtual void preprocess(PseudoJet & ) const {};
504 
505  /// a destructor to be replaced if necessary in derived classes...
506  virtual ~Recombiner() {};
507 
508  /// pa += pb in the given recombination scheme. Not virtual -- the
509  /// user should have no reason to want to redefine this!
510  inline void plus_equal(PseudoJet & pa, const PseudoJet & pb) const {
511  // put result in a temporary location in case the recombiner
512  // does something funny (ours doesn't, but who knows about the
513  // user's)
514  PseudoJet pres;
515  recombine(pa,pb,pres);
516  pa = pres;
517  }
518 
519  };
520 
521 
522  //======================================================================
523  /// @ingroup advanced_usage
524  /// \class DefaultRecombiner
525  /// A class that will provide the recombination scheme facilities and/or
526  /// allow a user to extend these facilities
527  ///
528  /// This class is derived from the (abstract) class Recombiner. It
529  /// simply "sums" PseudoJets using a specified recombination scheme
530  /// (E-scheme by default)
531  class DefaultRecombiner : public Recombiner {
532  public:
534  _recomb_scheme(recomb_scheme) {}
535 
536  virtual std::string description() const FASTJET_OVERRIDE;
537 
538  /// recombine pa and pb and put result into pab
539  virtual void recombine(const PseudoJet & pa, const PseudoJet & pb,
540  PseudoJet & pab) const FASTJET_OVERRIDE;
541 
542  virtual void preprocess(PseudoJet & p) const FASTJET_OVERRIDE;
543 
544  /// return the index of the recombination scheme
545  RecombinationScheme scheme() const {return _recomb_scheme;}
546 
547  private:
548  RecombinationScheme _recomb_scheme;
549  };
550 
551 
552  //======================================================================
553  /// @ingroup advanced_usage
554  /// \class Plugin
555  /// a class that allows a user to introduce their own "plugin" jet
556  /// finder
557  ///
558  /// Note that all the plugins provided with FastJet are derived from
559  /// this class
560  class Plugin{
561  public:
562  /// return a textual description of the jet-definition implemented
563  /// in this plugin
564  virtual std::string description() const = 0;
565 
566  /// given a ClusterSequence that has been filled up with initial
567  /// particles, the following function should fill up the rest of the
568  /// ClusterSequence, using the following member functions of
569  /// ClusterSequence:
570  /// - plugin_do_ij_recombination(...)
571  /// - plugin_do_iB_recombination(...)
572  virtual void run_clustering(ClusterSequence &) const = 0;
573 
574  virtual double R() const = 0;
575 
576  /// return true if there is specific support for the measurement
577  /// of passive areas, in the sense that areas determined from all
578  /// particles below the ghost separation scale will be a passive
579  /// area. [If you don't understand this, ignore it!]
580  virtual bool supports_ghosted_passive_areas() const {return false;}
581 
582  /// set the ghost separation scale for passive area determinations
583  /// in future runs (strictly speaking that makes the routine
584  /// a non const, so related internal info must be stored as a mutable)
585  virtual void set_ghost_separation_scale(double scale) const;
586  virtual double ghost_separation_scale() const {return 0.0;}
587 
588  /// if this returns false then a warning will be given
589  /// whenever the user requests "exclusive" jets from the
590  /// cluster sequence
591  virtual bool exclusive_sequence_meaningful() const {return false;}
592 
593  /// returns true if the plugin implements an algorithm intended
594  /// for use on a spherical geometry (e.g. e+e- algorithms, as
595  /// opposed to most pp algorithms, which use a cylindrical,
596  /// rapidity-phi geometry).
597  virtual bool is_spherical() const {return false;}
598 
599  /// a destructor to be replaced if necessary in derived classes...
600  virtual ~Plugin() {};
601  };
602 
603 private:
604 
605 
606  JetAlgorithm _jet_algorithm;
607  double _Rparam;
608  double _extra_param ; ///< parameter whose meaning varies according to context
609  Strategy _strategy ;
610 
611  const Plugin * _plugin;
612  SharedPtr<const Plugin> _plugin_shared;
613 
614  // when we use our own recombiner it's useful to point to it here
615  // so that we don't have to worry about deleting it etc...
616  DefaultRecombiner _default_recombiner;
617  const Recombiner * _recombiner;
618  SharedPtr<const Recombiner> _shared_recombiner;
619 
620 };
621 
622 
623 //-------------------------------------------------------------------------------
624 // helper functions to build a jet made of pieces
625 //
626 // These functions include an options recombiner used to compute the
627 // total composite jet momentum
628 // -------------------------------------------------------------------------------
629 
630 /// build a "CompositeJet" from the vector of its pieces
631 ///
632 /// In this case, E-scheme recombination is assumed to compute the
633 /// total momentum
634 PseudoJet join(const std::vector<PseudoJet> & pieces, const JetDefinition::Recombiner & recombiner);
635 
636 /// build a MergedJet from a single PseudoJet
637 PseudoJet join(const PseudoJet & j1,
638  const JetDefinition::Recombiner & recombiner);
639 
640 /// build a MergedJet from 2 PseudoJet
641 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2,
642  const JetDefinition::Recombiner & recombiner);
643 
644 /// build a MergedJet from 3 PseudoJet
645 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2, const PseudoJet & j3,
646  const JetDefinition::Recombiner & recombiner);
647 
648 /// build a MergedJet from 4 PseudoJet
649 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2, const PseudoJet & j3, const PseudoJet & j4,
650  const JetDefinition::Recombiner & recombiner);
651 
652 
653 FASTJET_END_NAMESPACE
654 
655 // include ClusterSequence which includes the implementation of the
656 // templated JetDefinition::operator()(...) member
657 #include "fastjet/ClusterSequence.hh"
658 
659 
660 #endif // __FASTJET_JETDEFINITION_HH__
JetAlgorithm jet_finder() const
same as above for backward compatibility
pt weighted recombination of y,phi (and summing of pt&#39;s), with no preprocessing
a version of cambridge with a special distance measure for particles whose pt is < extra_param(); thi...
like the k_t but with distance measures dij = min(kti^{2p},ktj^{2p}) Delta R_{ij}^2 / R^2 diB = 1/kti...
Chan&#39;s closest pair method (in a variant with 4pi coverage), for use exclusively with the Cambridge a...
summing the 4-momenta
JetDefinition(JetAlgorithm jet_algorithm_in, double R_in, const Recombiner *recombiner_in, Strategy strategy_in=Best)
constructor in a form that allows the user to provide a pointer to an external recombiner class (whic...
const Plugin * plugin() const
return a pointer to the plugin
JetAlgorithm jet_algorithm() const
return information about the definition...
void set_jet_finder(JetAlgorithm njf)
same as above for backward compatibility
deals with clustering
best of the NlnN variants – best overall for N>10^4.
Similar to N2MHTLazy9, but uses tiles of size R/2 and a 5x5 tile grid around the particle.
the value for the jet algorithm in a JetDefinition for which no algorithm has yet been defined ...
pt^2 weighted recombination of y,phi (and summing of pt&#39;s) no preprocessing
legacy N ln N using 4pi coverage of cylinder
pt^2 weighted recombination of y,phi (and summing of pt&#39;s) with preprocessing to make things massless...
JetDefinition(const Plugin *plugin_in)
constructor based on a pointer to a user&#39;s plugin; the object pointed to must remain valid for the wh...
JetDefinition(JetAlgorithm jet_algorithm_in, double R_in, RecombinationScheme recomb_scheme_in=E_scheme, Strategy strategy_in=Best)
constructor with alternative ordering or arguments – note that we have not provided a default jet fi...
virtual bool exclusive_sequence_meaningful() const
if this returns false then a warning will be given whenever the user requests "exclusive" jets from t...
the e+e- genkt algorithm (R > 2 and p=1 gives ee_kt)
JetDefinition(JetAlgorithm jet_algorithm_in, double R_in, double xtra_param_in, const Recombiner *recombiner_in, Strategy strategy_in=Best)
constructor allowing the extra parameter to be set and a pointer to a recombiner
fastest from about 50..500
the longitudinally invariant kt algorithm
pt-based Winner-Takes-All (WTA) recombination: the result of the recombination has the rapidity...
void set_extra_param(double xtra_param)
(re)set the general purpose extra parameter
Chan&#39;s closest pair method (in a variant with 2pi+minimal extra variant), for use exclusively with th...
JetDefinition()
a default constructor which creates a jet definition that is in a well-defined internal state...
any plugin algorithm supplied by the user
mod-p-based Winner-Takes-All (WTA) recombination: the result of the recombination gets the 3-vector d...
Like N2MHTLazy9 in a number of respects, but does not calculate ghost-ghost distances and so does not...
the plugin has been used...
virtual ~Plugin()
a destructor to be replaced if necessary in derived classes...
A class that will provide the recombination scheme facilities and/or allow a user to extend these fac...
virtual void preprocess(PseudoJet &) const
routine called to preprocess each input jet (to make all input jets compatible with the scheme requir...
const Recombiner * recombiner() const
returns a pointer to the currently defined recombiner.
pt^2 weighted recombination of y,phi (and summing of pt&#39;s) with preprocessing to make things massless...
worse even than the usual N^3 algorithms
Like to N2MHTLazy9 but uses slightly different optimizations, e.g.
RecombinationScheme
The various recombination schemes.
string fastjet_version_string()
return a string containing information about the release
the automatic strategy choice that was being made in FJ 3.0 (restricted to strategies that were prese...
automatic selection of the best (based on N), including the LazyTiled strategies that are new to FJ3...
static const double max_allowable_R
R values larger than max_allowable_R are not allowed.
an implementation of C++0x shared pointers (or boost&#39;s)
Definition: SharedPtr.hh:121
pt weighted recombination of y,phi (and summing of pt&#39;s) with preprocessing to make things massless b...
fastest below 50
pt weighted recombination of y,phi (and summing of pt&#39;s) with preprocessing to make things massless b...
const JetAlgorithm aachen_algorithm
provide other possible names for the Cambridge/Aachen algorithm
virtual bool is_spherical() const
returns true if the plugin implements an algorithm intended for use on a spherical geometry (e...
JetDefinition(JetAlgorithm jet_algorithm_in, RecombinationScheme recomb_scheme_in=E_scheme, Strategy strategy_in=Best)
constructor for algorithms that have no free parameters (e.g.
void set_recombiner(const Recombiner *recomb)
set the recombiner class to the one provided
like the k_t but with distance measures dij = min(1/kti^2,1/ktj^2) Delta R_{ij}^2 / R^2 diB = 1/kti^2...
the e+e- kt algorithm
the longitudinally invariant variant of the cambridge algorithm (aka Aachen algoithm).
virtual ~Recombiner()
a destructor to be replaced if necessary in derived classes...
a class that allows a user to introduce their own "plugin" jet finder
JetDefinition(JetAlgorithm jet_algorithm_in, double R_in, double xtra_param_in, RecombinationScheme recomb_scheme_in=E_scheme, Strategy strategy_in=Best)
constructor for algorithms that require R + one extra parameter to be set (the gen-kt series for exam...
An abstract base class that will provide the recombination scheme facilities and/or allow a user to e...
JetAlgorithm
the various families of jet-clustering algorithm
only looks into a neighbouring tile for a particle&#39;s nearest neighbour (NN) if that particle&#39;s in-til...
Strategy
the various options for the algorithmic strategy to adopt in clustering events with kt and cambridge ...
JetDefinition(JetAlgorithm jet_algorithm_in, const Recombiner *recombiner_in, Strategy strategy_in=Best)
constructor for case with 0 parameters (ee_kt_algorithm) and and external recombiner ...
RecombinationScheme scheme() const
return the index of the recombination scheme
Class to contain pseudojets, including minimal information of use to jet-clustering routines...
Definition: PseudoJet.hh:67
virtual bool supports_ghosted_passive_areas() const
return true if there is specific support for the measurement of passive areas, in the sense that area...
void plus_equal(PseudoJet &pa, const PseudoJet &pb) const
pa += pb in the given recombination scheme.
legacy N ln N using 3pi coverage of cylinder.
a version of genkt with a special distance measure for particles whose pt is < extra_param() [relevan...
faster that N2Tiled above about 500 particles; differs from it by retainig the di(closest j) distance...
void set_jet_algorithm(JetAlgorithm njf)
(re)set the jet finder
Chan&#39;s closest pair method (in a variant with 2pi+2R coverage), for use exclusively with the Cambridg...
for the user&#39;s external scheme
class that is intended to hold a full definition of the jet clusterer