FastJet  3.0.6
JetDefinition.hh
1 //STARTHEADER
2 // $Id: JetDefinition.hh 2687 2011-11-14 11:17:51Z soyez $
3 //
4 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
5 //
6 //----------------------------------------------------------------------
7 // This file is part of FastJet.
8 //
9 // FastJet is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 2 of the License, or
12 // (at your option) any later version.
13 //
14 // The algorithms that underlie FastJet have required considerable
15 // development and are described in hep-ph/0512210. If you use
16 // FastJet as part of work towards a scientific publication, please
17 // include a citation to the FastJet paper.
18 //
19 // FastJet is distributed in the hope that it will be useful,
20 // but WITHOUT ANY WARRANTY; without even the implied warranty of
21 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 // GNU General Public License for more details.
23 //
24 // You should have received a copy of the GNU General Public License
25 // along with FastJet. If not, see <http://www.gnu.org/licenses/>.
26 //----------------------------------------------------------------------
27 //ENDHEADER
28 
29 #ifndef __FASTJET_JETDEFINITION_HH__
30 #define __FASTJET_JETDEFINITION_HH__
31 
32 #include<cassert>
33 #include "fastjet/internal/numconsts.hh"
34 #include "fastjet/PseudoJet.hh"
35 #include<string>
36 #include<memory>
37 
38 FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh
39 
40 /// return a string containing information about the release
41 // NB: (implemented in ClusterSequence.cc but defined here because
42 // this is a visible location)
43 std::string fastjet_version_string();
44 
45 //======================================================================
46 /// the various options for the algorithmic strategy to adopt in
47 /// clustering events with kt and cambridge style algorithms.
48 enum Strategy {
49  /// fastest form about 500..10^4
51  /// fastest from about 50..500
52  N2Tiled = -3,
53  /// legacy
54  N2PoorTiled = -2,
55  /// fastest below 50
56  N2Plain = -1,
57  /// worse even than the usual N^3 algorithms
58  N3Dumb = 0,
59  /// automatic selection of the best (based on N)
60  Best = 1,
61  /// best of the NlnN variants -- best overall for N>10^4.
62  /// (Does not work for R>=2pi)
63  NlnN = 2,
64  /// legacy N ln N using 3pi coverage of cylinder.
65  /// (Does not work for R>=2pi)
66  NlnN3pi = 3,
67  /// legacy N ln N using 4pi coverage of cylinder
68  NlnN4pi = 4,
69  /// Chan's closest pair method (in a variant with 4pi coverage),
70  /// for use exclusively with the Cambridge algorithm.
71  /// (Does not work for R>=2pi)
72  NlnNCam4pi = 14,
73  /// Chan's closest pair method (in a variant with 2pi+2R coverage),
74  /// for use exclusively with the Cambridge algorithm.
75  /// (Does not work for R>=2pi)
77  /// Chan's closest pair method (in a variant with 2pi+minimal extra
78  /// variant), for use exclusively with the Cambridge algorithm.
79  /// (Does not work for R>=2pi)
80  NlnNCam = 12, // 2piMultD
81  /// the plugin has been used...
83 };
84 
85 
86 //======================================================================
87 /// \enum JetAlgorithm
88 /// the various families of jet-clustering algorithm
90  /// the longitudinally invariant kt algorithm
92  /// the longitudinally invariant variant of the cambridge algorithm
93  /// (aka Aachen algoithm).
95  /// like the k_t but with distance measures
96  /// dij = min(1/kti^2,1/ktj^2) Delta R_{ij}^2 / R^2
97  /// diB = 1/kti^2
99  /// like the k_t but with distance measures
100  /// dij = min(kti^{2p},ktj^{2p}) Delta R_{ij}^2 / R^2
101  /// diB = 1/kti^{2p}
102  /// where p = extra_param()
104  /// a version of cambridge with a special distance measure for particles
105  /// whose pt is < extra_param()
107  /// a version of genkt with a special distance measure for particles
108  /// whose pt is < extra_param() [relevant for passive areas when p<=0]
110  //.................................................................
111  /// the e+e- kt algorithm
113  /// the e+e- genkt algorithm (R > 2 and p=1 gives ee_kt)
115  //.................................................................
116  /// any plugin algorithm supplied by the user
118  //.................................................................
119  /// the value for the jet algorithm in a JetDefinition for which
120  /// no algorithm has yet been defined
122 };
123 
124 /// make standard Les Houches nomenclature JetAlgorithm (algorithm is general
125 /// recipe without the parameters) backward-compatible with old JetFinder
127 
128 /// provide other possible names for the Cambridge/Aachen algorithm
130 const JetAlgorithm cambridge_aachen_algorithm = cambridge_algorithm;
131 
132 //======================================================================
133 /// the various recombination schemes
135  /// summing the 4-momenta
137  /// pt weighted recombination of y,phi (and summing of pt's)
138  /// with preprocessing to make things massless by rescaling E=|\vec p|
140  /// pt^2 weighted recombination of y,phi (and summing of pt's)
141  /// with preprocessing to make things massless by rescaling E=|\vec p|
143  /// pt weighted recombination of y,phi (and summing of pt's)
144  /// with preprocessing to make things massless by rescaling |\vec p|->=E
146  /// pt^2 weighted recombination of y,phi (and summing of pt's)
147  /// with preprocessing to make things massless by rescaling |\vec p|->=E
149  /// pt weighted recombination of y,phi (and summing of pt's), with
150  /// no preprocessing
152  /// pt^2 weighted recombination of y,phi (and summing of pt's)
153  /// no preprocessing
155  /// for the user's external scheme
157 };
158 
159 
160 
161 // forward declaration, needed in order to specify interface for the
162 // plugin.
163 class ClusterSequence;
164 
165 
166 
167 
168 //======================================================================
169 /// @ingroup basic_classes
170 /// \class JetDefinition
171 /// class that is intended to hold a full definition of the jet
172 /// clusterer
174 
175 public:
176 
177  /// forward declaration of a class that allows the user to introduce
178  /// their own plugin
179  class Plugin;
180 
181  // forward declaration of a class that will provide the
182  // recombination scheme facilities and/or allow a user to
183  // extend these facilities
184  class Recombiner;
185 
186 
187  /// constructor with alternative ordering or arguments -- note that
188  /// we have not provided a default jet finder, to avoid ambiguous
189  /// JetDefinition() constructor.
190  JetDefinition(JetAlgorithm jet_algorithm_in,
191  double R_in,
192  RecombinationScheme recomb_scheme_in = E_scheme,
193  Strategy strategy_in = Best) {
194  *this = JetDefinition(jet_algorithm_in, R_in, strategy_in, recomb_scheme_in, 1);
195  }
196 
197  /// constructor for algorithms that have no free parameters
198  /// (e.g. ee_kt_algorithm)
199  JetDefinition(JetAlgorithm jet_algorithm_in,
200  RecombinationScheme recomb_scheme_in = E_scheme,
201  Strategy strategy_in = Best) {
202  double dummyR = 0.0;
203  *this = JetDefinition(jet_algorithm_in, dummyR, strategy_in, recomb_scheme_in, 0);
204  }
205 
206  /// constructor for algorithms that require R + one extra parameter to be set
207  /// (the gen-kt series for example)
208  JetDefinition(JetAlgorithm jet_algorithm_in,
209  double R_in,
210  double xtra_param_in,
211  RecombinationScheme recomb_scheme_in = E_scheme,
212  Strategy strategy_in = Best) {
213  *this = JetDefinition(jet_algorithm_in, R_in, strategy_in, recomb_scheme_in, 2);
214  set_extra_param(xtra_param_in);
215  }
216 
217 
218  /// constructor in a form that allows the user to provide a pointer
219  /// to an external recombiner class (which must remain valid for the
220  /// life of the JetDefinition object).
221  JetDefinition(JetAlgorithm jet_algorithm_in,
222  double R_in,
223  const Recombiner * recombiner_in,
224  Strategy strategy_in = Best) {
225  *this = JetDefinition(jet_algorithm_in, R_in, external_scheme, strategy_in);
226  _recombiner = recombiner_in;
227  }
228 
229 
230  /// constructor for case with 0 parameters (ee_kt_algorithm) and
231  /// and external recombiner
232  JetDefinition(JetAlgorithm jet_algorithm_in,
233  const Recombiner * recombiner_in,
234  Strategy strategy_in = Best) {
235  *this = JetDefinition(jet_algorithm_in, external_scheme, strategy_in);
236  _recombiner = recombiner_in;
237  }
238 
239  /// constructor allowing the extra parameter to be set and a pointer to
240  /// a recombiner
241  JetDefinition(JetAlgorithm jet_algorithm_in,
242  double R_in,
243  double xtra_param_in,
244  const Recombiner * recombiner_in,
245  Strategy strategy_in = Best) {
246  *this = JetDefinition(jet_algorithm_in, R_in, external_scheme, strategy_in);
247  _recombiner = recombiner_in;
248  set_extra_param(xtra_param_in);
249  }
250 
251  /// a default constructor which creates a jet definition that is in
252  /// a well-defined internal state, but not actually usable for jet
253  /// clustering.
256  }
257 
258 
259  // /// a default constructor
260  // JetDefinition() {
261  // *this = JetDefinition(kt_algorithm, 1.0);
262  // }
263 
264  /// constructor based on a pointer to a user's plugin; the object
265  /// pointed to must remain valid for the whole duration of existence
266  /// of the JetDefinition and any related ClusterSequences
267  JetDefinition(const Plugin * plugin_in) {
268  _plugin = plugin_in;
269  _strategy = plugin_strategy;
270  _Rparam = _plugin->R();
271  _jet_algorithm = plugin_algorithm;
272  set_recombination_scheme(E_scheme);
273  }
274 
275 
276  /// constructor to fully specify a jet-definition (together with
277  /// information about how algorithically to run it).
278  ///
279  /// the ordering of arguments here is old and deprecated (except
280  /// as the common constructor for internal use)
281  JetDefinition(JetAlgorithm jet_algorithm_in,
282  double R_in,
283  Strategy strategy_in,
284  RecombinationScheme recomb_scheme_in = E_scheme,
285  int nparameters_in = 1);
286 
287  /// R values larger than max_allowable_R are not allowed.
288  ///
289  /// We use a value of 1000, substantially smaller than
290  /// numeric_limits<double>::max(), to leave room for the convention
291  /// within PseudoJet of setting unphysical (infinite) rapidities to
292  /// +-(MaxRap + abs(pz())), where MaxRap is 10^5.
293  static const double max_allowable_R; //= 1000.0;
294 
295  /// set the recombination scheme to the one provided
296  void set_recombination_scheme(RecombinationScheme);
297 
298  /// set the recombiner class to the one provided
299  void set_recombiner(const Recombiner * recomb) {
300  if (_recombiner_shared()) _recombiner_shared.reset(recomb);
301  _recombiner = recomb;
302  _default_recombiner = DefaultRecombiner(external_scheme);
303  }
304 
305  /// calling this tells the JetDefinition to handle the deletion of
306  /// the recombiner when it is no longer used
307  void delete_recombiner_when_unused();
308 
309  /// return a pointer to the plugin
310  const Plugin * plugin() const {return _plugin;};
311 
312  /// allows to let the JetDefinition handle the deletion of the
313  /// plugin when it is no longer used
314  void delete_plugin_when_unused();
315 
316  /// return information about the definition...
317  JetAlgorithm jet_algorithm () const {return _jet_algorithm ;}
318  /// same as above for backward compatibility
319  JetAlgorithm jet_finder () const {return _jet_algorithm ;}
320  double R () const {return _Rparam ;}
321  // a general purpose extra parameter, whose meaning depends on
322  // the algorithm, and may often be unused.
323  double extra_param () const {return _extra_param ;}
324  Strategy strategy () const {return _strategy ;}
325  RecombinationScheme recombination_scheme() const {
326  return _default_recombiner.scheme();}
327 
328  /// (re)set the jet finder
329  void set_jet_algorithm(JetAlgorithm njf) {_jet_algorithm = njf;}
330  /// same as above for backward compatibility
331  void set_jet_finder(JetAlgorithm njf) {_jet_algorithm = njf;}
332  /// (re)set the general purpose extra parameter
333  void set_extra_param(double xtra_param) {_extra_param = xtra_param;}
334 
335  /// return a pointer to the currently defined recombiner.
336  ///
337  /// Warning: the pointer may be to an internal recombiner (for
338  /// default recombination schemes), in which case if the
339  /// JetDefinition becomes invalid (e.g. is deleted), the pointer
340  /// will then point to an object that no longer exists.
341  ///
342  /// Note also that if you copy a JetDefinition with a default
343  /// recombination scheme, then the two copies will have distinct
344  /// recombiners, and return different recombiner() pointers.
345  const Recombiner * recombiner() const {
346  return _recombiner == 0 ? & _default_recombiner : _recombiner;}
347 
348  /// returns true if the current jet definitions shares the same
349  /// recombiner as teh one passed as an argument
350  bool has_same_recombiner(const JetDefinition &other_jd) const;
351 
352  /// return a textual description of the current jet definition
353  std::string description() const;
354 
355 
356 public:
357  //======================================================================
358  /// @ingroup advanced_usage
359  /// \class Recombiner
360  /// An abstract base class that will provide the recombination scheme
361  /// facilities and/or allow a user to extend these facilities
362  class Recombiner {
363  public:
364  /// return a textual description of the recombination scheme
365  /// implemented here
366  virtual std::string description() const = 0;
367 
368  /// recombine pa and pb and put result into pab
369  virtual void recombine(const PseudoJet & pa, const PseudoJet & pb,
370  PseudoJet & pab) const = 0;
371 
372  /// routine called to preprocess each input jet (to make all input
373  /// jets compatible with the scheme requirements (e.g. massless).
374  virtual void preprocess(PseudoJet & ) const {};
375 
376  /// a destructor to be replaced if necessary in derived classes...
377  virtual ~Recombiner() {};
378 
379  /// pa += pb in the given recombination scheme. Not virtual -- the
380  /// user should have no reason to want to redefine this!
381  inline void plus_equal(PseudoJet & pa, const PseudoJet & pb) const {
382  // put result in a temporary location in case the recombiner
383  // does something funny (ours doesn't, but who knows about the
384  // user's)
385  PseudoJet pres;
386  recombine(pa,pb,pres);
387  pa = pres;
388  }
389 
390  };
391 
392 
393  //======================================================================
394  /// @ingroup advanced_usage
395  /// \class DefaultRecombiner
396  /// A class that will provide the recombination scheme facilities and/or
397  /// allow a user to extend these facilities
398  ///
399  /// This class is derived from the (abstract) class Recombiner. It
400  /// simply "sums" PseudoJets using a specified recombination scheme
401  /// (E-scheme by default)
402  class DefaultRecombiner : public Recombiner {
403  public:
405  _recomb_scheme(recomb_scheme) {}
406 
407  virtual std::string description() const;
408 
409  /// recombine pa and pb and put result into pab
410  virtual void recombine(const PseudoJet & pa, const PseudoJet & pb,
411  PseudoJet & pab) const;
412 
413  virtual void preprocess(PseudoJet & p) const;
414 
415  /// return the index of the recombination scheme
416  RecombinationScheme scheme() const {return _recomb_scheme;}
417 
418  private:
419  RecombinationScheme _recomb_scheme;
420  };
421 
422 
423  //======================================================================
424  /// @ingroup advanced_usage
425  /// \class Plugin
426  /// a class that allows a user to introduce their own "plugin" jet
427  /// finder
428  ///
429  /// Note that all the plugins provided with FastJet are derived from
430  /// this class
431  class Plugin{
432  public:
433  /// return a textual description of the jet-definition implemented
434  /// in this plugin
435  virtual std::string description() const = 0;
436 
437  /// given a ClusterSequence that has been filled up with initial
438  /// particles, the following function should fill up the rest of the
439  /// ClusterSequence, using the following member functions of
440  /// ClusterSequence:
441  /// - plugin_do_ij_recombination(...)
442  /// - plugin_do_iB_recombination(...)
443  virtual void run_clustering(ClusterSequence &) const = 0;
444 
445  virtual double R() const = 0;
446 
447  /// return true if there is specific support for the measurement
448  /// of passive areas, in the sense that areas determined from all
449  /// particles below the ghost separation scale will be a passive
450  /// area. [If you don't understand this, ignore it!]
451  virtual bool supports_ghosted_passive_areas() const {return false;}
452 
453  /// set the ghost separation scale for passive area determinations
454  /// in future runs (strictly speaking that makes the routine
455  /// a non const, so related internal info must be stored as a mutable)
456  virtual void set_ghost_separation_scale(double scale) const;
457  virtual double ghost_separation_scale() const {return 0.0;}
458 
459  /// if this returns false then a warning will be given
460  /// whenever the user requests "exclusive" jets from the
461  /// cluster sequence
462  virtual bool exclusive_sequence_meaningful() const {return false;}
463 
464  /// a destructor to be replaced if necessary in derived classes...
465  virtual ~Plugin() {};
466  };
467 
468 private:
469 
470 
471  JetAlgorithm _jet_algorithm;
472  double _Rparam;
473  double _extra_param ; ///< parameter whose meaning varies according to context
474  Strategy _strategy ;
475 
476  const Plugin * _plugin;
477  SharedPtr<const Plugin> _plugin_shared;
478 
479  // when we use our own recombiner it's useful to point to it here
480  // so that we don't have to worry about deleting it etc...
481  DefaultRecombiner _default_recombiner;
482  const Recombiner * _recombiner;
483  SharedPtr<const Recombiner> _recombiner_shared;
484 
485 };
486 
487 
488 //-------------------------------------------------------------------------------
489 // helper functions to build a jet made of pieces
490 //
491 // These functions include an options recombiner used to compute the
492 // total composite jet momentum
493 // -------------------------------------------------------------------------------
494 
495 /// build a "CompositeJet" from the vector of its pieces
496 ///
497 /// In this case, E-scheme recombination is assumed to compute the
498 /// total momentum
499 PseudoJet join(const std::vector<PseudoJet> & pieces, const JetDefinition::Recombiner & recombiner);
500 
501 /// build a MergedJet from a single PseudoJet
502 PseudoJet join(const PseudoJet & j1,
503  const JetDefinition::Recombiner & recombiner);
504 
505 /// build a MergedJet from 2 PseudoJet
506 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2,
507  const JetDefinition::Recombiner & recombiner);
508 
509 /// build a MergedJet from 3 PseudoJet
510 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2, const PseudoJet & j3,
511  const JetDefinition::Recombiner & recombiner);
512 
513 /// build a MergedJet from 4 PseudoJet
514 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2, const PseudoJet & j3, const PseudoJet & j4,
515  const JetDefinition::Recombiner & recombiner);
516 
517 
518 
519 
520 
521 FASTJET_END_NAMESPACE
522 
523 #endif // __FASTJET_JETDEFINITION_HH__
pt weighted recombination of y,phi (and summing of pt's), with no preprocessing
a version of cambridge with a special distance measure for particles whose pt is < extra_param() ...
like the k_t but with distance measures dij = min(kti^{2p},ktj^{2p}) Delta R_{ij}^2 / R^2 diB = 1/kti...
Chan'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...
RecombinationScheme scheme() const
return the index of the recombination scheme
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.
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's) no preprocessing
legacy N ln N using 4pi coverage of cylinder
JetAlgorithm jet_algorithm() const
return information about the definition...
pt^2 weighted recombination of y,phi (and summing of pt's) with preprocessing to make things massless...
JetDefinition(const Plugin *plugin_in)
constructor based on a pointer to a user'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...
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
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...
the longitudinally invariant kt algorithm
const Plugin * plugin() const
return a pointer to the plugin
void set_extra_param(double xtra_param)
(re)set the general purpose extra parameter
Chan'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
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...
pt^2 weighted recombination of y,phi (and summing of pt's) with preprocessing to make things massless...
worse even than the usual N^3 algorithms
JetAlgorithm jet_finder() const
same as above for backward compatibility
RecombinationScheme
the various recombination schemes
string fastjet_version_string()
return a string containing information about the release
void plus_equal(PseudoJet &pa, const PseudoJet &pb) const
pa += pb in the given recombination scheme.
automatic selection of the best (based on N)
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's)
Definition: SharedPtr.hh:114
pt weighted recombination of y,phi (and summing of pt's) with preprocessing to make things massless b...
fastest below 50
pt weighted recombination of y,phi (and summing of pt's) with preprocessing to make things massless b...
const Recombiner * recombiner() const
return a pointer to the currently defined recombiner.
const JetAlgorithm aachen_algorithm
provide other possible names for the Cambridge/Aachen algorithm
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...
virtual void preprocess(PseudoJet &) const
routine called to preprocess each input jet (to make all input jets compatible with the scheme requir...
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
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 ...
Class to contain pseudojets, including minimal information of use to jet-clustering routines...
Definition: PseudoJet.hh:65
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...
fastest form about 500..10^4
void set_jet_algorithm(JetAlgorithm njf)
(re)set the jet finder
Chan's closest pair method (in a variant with 2pi+2R coverage), for use exclusively with the Cambridg...
for the user's external scheme
class that is intended to hold a full definition of the jet clusterer
virtual bool exclusive_sequence_meaningful() const
if this returns false then a warning will be given whenever the user requests "exclusive" jets from t...