FastJet 3.0.2
|
00001 //STARTHEADER 00002 // $Id: JetDefinition.hh 2687 2011-11-14 11:17:51Z soyez $ 00003 // 00004 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez 00005 // 00006 //---------------------------------------------------------------------- 00007 // This file is part of FastJet. 00008 // 00009 // FastJet is free software; you can redistribute it and/or modify 00010 // it under the terms of the GNU General Public License as published by 00011 // the Free Software Foundation; either version 2 of the License, or 00012 // (at your option) any later version. 00013 // 00014 // The algorithms that underlie FastJet have required considerable 00015 // development and are described in hep-ph/0512210. If you use 00016 // FastJet as part of work towards a scientific publication, please 00017 // include a citation to the FastJet paper. 00018 // 00019 // FastJet is distributed in the hope that it will be useful, 00020 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00021 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00022 // GNU General Public License for more details. 00023 // 00024 // You should have received a copy of the GNU General Public License 00025 // along with FastJet. If not, see <http://www.gnu.org/licenses/>. 00026 //---------------------------------------------------------------------- 00027 //ENDHEADER 00028 00029 #ifndef __FASTJET_JETDEFINITION_HH__ 00030 #define __FASTJET_JETDEFINITION_HH__ 00031 00032 #include<cassert> 00033 #include "fastjet/internal/numconsts.hh" 00034 #include "fastjet/PseudoJet.hh" 00035 #include<string> 00036 #include<memory> 00037 00038 FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh 00039 00040 /// return a string containing information about the release 00041 // NB: (implemented in ClusterSequence.cc but defined here because 00042 // this is a visible location) 00043 std::string fastjet_version_string(); 00044 00045 //====================================================================== 00046 /// the various options for the algorithmic strategy to adopt in 00047 /// clustering events with kt and cambridge style algorithms. 00048 enum Strategy { 00049 /// fastest form about 500..10^4 00050 N2MinHeapTiled = -4, 00051 /// fastest from about 50..500 00052 N2Tiled = -3, 00053 /// legacy 00054 N2PoorTiled = -2, 00055 /// fastest below 50 00056 N2Plain = -1, 00057 /// worse even than the usual N^3 algorithms 00058 N3Dumb = 0, 00059 /// automatic selection of the best (based on N) 00060 Best = 1, 00061 /// best of the NlnN variants -- best overall for N>10^4. 00062 /// (Does not work for R>=2pi) 00063 NlnN = 2, 00064 /// legacy N ln N using 3pi coverage of cylinder. 00065 /// (Does not work for R>=2pi) 00066 NlnN3pi = 3, 00067 /// legacy N ln N using 4pi coverage of cylinder 00068 NlnN4pi = 4, 00069 /// Chan's closest pair method (in a variant with 4pi coverage), 00070 /// for use exclusively with the Cambridge algorithm. 00071 /// (Does not work for R>=2pi) 00072 NlnNCam4pi = 14, 00073 /// Chan's closest pair method (in a variant with 2pi+2R coverage), 00074 /// for use exclusively with the Cambridge algorithm. 00075 /// (Does not work for R>=2pi) 00076 NlnNCam2pi2R = 13, 00077 /// Chan's closest pair method (in a variant with 2pi+minimal extra 00078 /// variant), for use exclusively with the Cambridge algorithm. 00079 /// (Does not work for R>=2pi) 00080 NlnNCam = 12, // 2piMultD 00081 /// the plugin has been used... 00082 plugin_strategy = 999 00083 }; 00084 00085 00086 //====================================================================== 00087 /// \enum JetAlgorithm 00088 /// the various families of jet-clustering algorithm 00089 enum JetAlgorithm { 00090 /// the longitudinally invariant kt algorithm 00091 kt_algorithm=0, 00092 /// the longitudinally invariant variant of the cambridge algorithm 00093 /// (aka Aachen algoithm). 00094 cambridge_algorithm=1, 00095 /// like the k_t but with distance measures 00096 /// dij = min(1/kti^2,1/ktj^2) Delta R_{ij}^2 / R^2 00097 /// diB = 1/kti^2 00098 antikt_algorithm=2, 00099 /// like the k_t but with distance measures 00100 /// dij = min(kti^{2p},ktj^{2p}) Delta R_{ij}^2 / R^2 00101 /// diB = 1/kti^{2p} 00102 /// where p = extra_param() 00103 genkt_algorithm=3, 00104 /// a version of cambridge with a special distance measure for particles 00105 /// whose pt is < extra_param() 00106 cambridge_for_passive_algorithm=11, 00107 /// a version of genkt with a special distance measure for particles 00108 /// whose pt is < extra_param() [relevant for passive areas when p<=0] 00109 genkt_for_passive_algorithm=13, 00110 //................................................................. 00111 /// the e+e- kt algorithm 00112 ee_kt_algorithm=50, 00113 /// the e+e- genkt algorithm (R > 2 and p=1 gives ee_kt) 00114 ee_genkt_algorithm=53, 00115 //................................................................. 00116 /// any plugin algorithm supplied by the user 00117 plugin_algorithm = 99, 00118 //................................................................. 00119 /// the value for the jet algorithm in a JetDefinition for which 00120 /// no algorithm has yet been defined 00121 undefined_jet_algorithm = 999 00122 }; 00123 00124 /// make standard Les Houches nomenclature JetAlgorithm (algorithm is general 00125 /// recipe without the parameters) backward-compatible with old JetFinder 00126 typedef JetAlgorithm JetFinder; 00127 00128 /// provide other possible names for the Cambridge/Aachen algorithm 00129 const JetAlgorithm aachen_algorithm = cambridge_algorithm; 00130 const JetAlgorithm cambridge_aachen_algorithm = cambridge_algorithm; 00131 00132 //====================================================================== 00133 /// the various recombination schemes 00134 enum RecombinationScheme { 00135 /// summing the 4-momenta 00136 E_scheme=0, 00137 /// pt weighted recombination of y,phi (and summing of pt's) 00138 /// with preprocessing to make things massless by rescaling E=|\vec p| 00139 pt_scheme=1, 00140 /// pt^2 weighted recombination of y,phi (and summing of pt's) 00141 /// with preprocessing to make things massless by rescaling E=|\vec p| 00142 pt2_scheme=2, 00143 /// pt weighted recombination of y,phi (and summing of pt's) 00144 /// with preprocessing to make things massless by rescaling |\vec p|->=E 00145 Et_scheme=3, 00146 /// pt^2 weighted recombination of y,phi (and summing of pt's) 00147 /// with preprocessing to make things massless by rescaling |\vec p|->=E 00148 Et2_scheme=4, 00149 /// pt weighted recombination of y,phi (and summing of pt's), with 00150 /// no preprocessing 00151 BIpt_scheme=5, 00152 /// pt^2 weighted recombination of y,phi (and summing of pt's) 00153 /// no preprocessing 00154 BIpt2_scheme=6, 00155 /// for the user's external scheme 00156 external_scheme = 99 00157 }; 00158 00159 00160 00161 // forward declaration, needed in order to specify interface for the 00162 // plugin. 00163 class ClusterSequence; 00164 00165 00166 00167 00168 //====================================================================== 00169 /// @ingroup basic_classes 00170 /// \class JetDefinition 00171 /// class that is intended to hold a full definition of the jet 00172 /// clusterer 00173 class JetDefinition { 00174 00175 public: 00176 00177 /// forward declaration of a class that allows the user to introduce 00178 /// their own plugin 00179 class Plugin; 00180 00181 // forward declaration of a class that will provide the 00182 // recombination scheme facilities and/or allow a user to 00183 // extend these facilities 00184 class Recombiner; 00185 00186 00187 /// constructor with alternative ordering or arguments -- note that 00188 /// we have not provided a default jet finder, to avoid ambiguous 00189 /// JetDefinition() constructor. 00190 JetDefinition(JetAlgorithm jet_algorithm_in, 00191 double R_in, 00192 RecombinationScheme recomb_scheme_in = E_scheme, 00193 Strategy strategy_in = Best) { 00194 *this = JetDefinition(jet_algorithm_in, R_in, strategy_in, recomb_scheme_in, 1); 00195 } 00196 00197 /// constructor for algorithms that have no free parameters 00198 /// (e.g. ee_kt_algorithm) 00199 JetDefinition(JetAlgorithm jet_algorithm_in, 00200 RecombinationScheme recomb_scheme_in = E_scheme, 00201 Strategy strategy_in = Best) { 00202 double dummyR = 0.0; 00203 *this = JetDefinition(jet_algorithm_in, dummyR, strategy_in, recomb_scheme_in, 0); 00204 } 00205 00206 /// constructor for algorithms that require R + one extra parameter to be set 00207 /// (the gen-kt series for example) 00208 JetDefinition(JetAlgorithm jet_algorithm_in, 00209 double R_in, 00210 double xtra_param_in, 00211 RecombinationScheme recomb_scheme_in = E_scheme, 00212 Strategy strategy_in = Best) { 00213 *this = JetDefinition(jet_algorithm_in, R_in, strategy_in, recomb_scheme_in, 2); 00214 set_extra_param(xtra_param_in); 00215 } 00216 00217 00218 /// constructor in a form that allows the user to provide a pointer 00219 /// to an external recombiner class (which must remain valid for the 00220 /// life of the JetDefinition object). 00221 JetDefinition(JetAlgorithm jet_algorithm_in, 00222 double R_in, 00223 const Recombiner * recombiner_in, 00224 Strategy strategy_in = Best) { 00225 *this = JetDefinition(jet_algorithm_in, R_in, external_scheme, strategy_in); 00226 _recombiner = recombiner_in; 00227 } 00228 00229 00230 /// constructor for case with 0 parameters (ee_kt_algorithm) and 00231 /// and external recombiner 00232 JetDefinition(JetAlgorithm jet_algorithm_in, 00233 const Recombiner * recombiner_in, 00234 Strategy strategy_in = Best) { 00235 *this = JetDefinition(jet_algorithm_in, external_scheme, strategy_in); 00236 _recombiner = recombiner_in; 00237 } 00238 00239 /// constructor allowing the extra parameter to be set and a pointer to 00240 /// a recombiner 00241 JetDefinition(JetAlgorithm jet_algorithm_in, 00242 double R_in, 00243 double xtra_param_in, 00244 const Recombiner * recombiner_in, 00245 Strategy strategy_in = Best) { 00246 *this = JetDefinition(jet_algorithm_in, R_in, external_scheme, strategy_in); 00247 _recombiner = recombiner_in; 00248 set_extra_param(xtra_param_in); 00249 } 00250 00251 /// a default constructor which creates a jet definition that is in 00252 /// a well-defined internal state, but not actually usable for jet 00253 /// clustering. 00254 JetDefinition() { 00255 *this = JetDefinition(undefined_jet_algorithm, 1.0); 00256 } 00257 00258 00259 // /// a default constructor 00260 // JetDefinition() { 00261 // *this = JetDefinition(kt_algorithm, 1.0); 00262 // } 00263 00264 /// constructor based on a pointer to a user's plugin; the object 00265 /// pointed to must remain valid for the whole duration of existence 00266 /// of the JetDefinition and any related ClusterSequences 00267 JetDefinition(const Plugin * plugin_in) { 00268 _plugin = plugin_in; 00269 _strategy = plugin_strategy; 00270 _Rparam = _plugin->R(); 00271 _jet_algorithm = plugin_algorithm; 00272 set_recombination_scheme(E_scheme); 00273 } 00274 00275 00276 /// constructor to fully specify a jet-definition (together with 00277 /// information about how algorithically to run it). 00278 /// 00279 /// the ordering of arguments here is old and deprecated (except 00280 /// as the common constructor for internal use) 00281 JetDefinition(JetAlgorithm jet_algorithm_in, 00282 double R_in, 00283 Strategy strategy_in, 00284 RecombinationScheme recomb_scheme_in = E_scheme, 00285 int nparameters_in = 1); 00286 00287 /// R values larger than max_allowable_R are not allowed. 00288 /// 00289 /// We use a value of 1000, substantially smaller than 00290 /// numeric_limits<double>::max(), to leave room for the convention 00291 /// within PseudoJet of setting unphysical (infinite) rapidities to 00292 /// +-(MaxRap + abs(pz())), where MaxRap is 10^5. 00293 static const double max_allowable_R; //= 1000.0; 00294 00295 /// set the recombination scheme to the one provided 00296 void set_recombination_scheme(RecombinationScheme); 00297 00298 /// set the recombiner class to the one provided 00299 void set_recombiner(const Recombiner * recomb) { 00300 if (_recombiner_shared()) _recombiner_shared.reset(recomb); 00301 _recombiner = recomb; 00302 _default_recombiner = DefaultRecombiner(external_scheme); 00303 } 00304 00305 /// calling this tells the JetDefinition to handle the deletion of 00306 /// the recombiner when it is no longer used 00307 void delete_recombiner_when_unused(); 00308 00309 /// return a pointer to the plugin 00310 const Plugin * plugin() const {return _plugin;}; 00311 00312 /// allows to let the JetDefinition handle the deletion of the 00313 /// plugin when it is no longer used 00314 void delete_plugin_when_unused(); 00315 00316 /// return information about the definition... 00317 JetAlgorithm jet_algorithm () const {return _jet_algorithm ;} 00318 /// same as above for backward compatibility 00319 JetAlgorithm jet_finder () const {return _jet_algorithm ;} 00320 double R () const {return _Rparam ;} 00321 // a general purpose extra parameter, whose meaning depends on 00322 // the algorithm, and may often be unused. 00323 double extra_param () const {return _extra_param ;} 00324 Strategy strategy () const {return _strategy ;} 00325 RecombinationScheme recombination_scheme() const { 00326 return _default_recombiner.scheme();} 00327 00328 /// (re)set the jet finder 00329 void set_jet_algorithm(JetAlgorithm njf) {_jet_algorithm = njf;} 00330 /// same as above for backward compatibility 00331 void set_jet_finder(JetAlgorithm njf) {_jet_algorithm = njf;} 00332 /// (re)set the general purpose extra parameter 00333 void set_extra_param(double xtra_param) {_extra_param = xtra_param;} 00334 00335 /// return a pointer to the currently defined recombiner. 00336 /// 00337 /// Warning: the pointer may be to an internal recombiner (for 00338 /// default recombination schemes), in which case if the 00339 /// JetDefinition becomes invalid (e.g. is deleted), the pointer 00340 /// will then point to an object that no longer exists. 00341 /// 00342 /// Note also that if you copy a JetDefinition with a default 00343 /// recombination scheme, then the two copies will have distinct 00344 /// recombiners, and return different recombiner() pointers. 00345 const Recombiner * recombiner() const { 00346 return _recombiner == 0 ? & _default_recombiner : _recombiner;} 00347 00348 /// returns true if the current jet definitions shares the same 00349 /// recombiner as teh one passed as an argument 00350 bool has_same_recombiner(const JetDefinition &other_jd) const; 00351 00352 /// return a textual description of the current jet definition 00353 std::string description() const; 00354 00355 00356 public: 00357 //====================================================================== 00358 /// @ingroup advanced_usage 00359 /// \class Recombiner 00360 /// An abstract base class that will provide the recombination scheme 00361 /// facilities and/or allow a user to extend these facilities 00362 class Recombiner { 00363 public: 00364 /// return a textual description of the recombination scheme 00365 /// implemented here 00366 virtual std::string description() const = 0; 00367 00368 /// recombine pa and pb and put result into pab 00369 virtual void recombine(const PseudoJet & pa, const PseudoJet & pb, 00370 PseudoJet & pab) const = 0; 00371 00372 /// routine called to preprocess each input jet (to make all input 00373 /// jets compatible with the scheme requirements (e.g. massless). 00374 virtual void preprocess(PseudoJet & ) const {}; 00375 00376 /// a destructor to be replaced if necessary in derived classes... 00377 virtual ~Recombiner() {}; 00378 00379 /// pa += pb in the given recombination scheme. Not virtual -- the 00380 /// user should have no reason to want to redefine this! 00381 inline void plus_equal(PseudoJet & pa, const PseudoJet & pb) const { 00382 // put result in a temporary location in case the recombiner 00383 // does something funny (ours doesn't, but who knows about the 00384 // user's) 00385 PseudoJet pres; 00386 recombine(pa,pb,pres); 00387 pa = pres; 00388 } 00389 00390 }; 00391 00392 00393 //====================================================================== 00394 /// @ingroup advanced_usage 00395 /// \class DefaultRecombiner 00396 /// A class that will provide the recombination scheme facilities and/or 00397 /// allow a user to extend these facilities 00398 /// 00399 /// This class is derived from the (abstract) class Recombiner. It 00400 /// simply "sums" PseudoJets using a specified recombination scheme 00401 /// (E-scheme by default) 00402 class DefaultRecombiner : public Recombiner { 00403 public: 00404 DefaultRecombiner(RecombinationScheme recomb_scheme = E_scheme) : 00405 _recomb_scheme(recomb_scheme) {} 00406 00407 virtual std::string description() const; 00408 00409 /// recombine pa and pb and put result into pab 00410 virtual void recombine(const PseudoJet & pa, const PseudoJet & pb, 00411 PseudoJet & pab) const; 00412 00413 virtual void preprocess(PseudoJet & p) const; 00414 00415 /// return the index of the recombination scheme 00416 RecombinationScheme scheme() const {return _recomb_scheme;} 00417 00418 private: 00419 RecombinationScheme _recomb_scheme; 00420 }; 00421 00422 00423 //====================================================================== 00424 /// @ingroup advanced_usage 00425 /// \class Plugin 00426 /// a class that allows a user to introduce their own "plugin" jet 00427 /// finder 00428 /// 00429 /// Note that all the plugins provided with FastJet are derived from 00430 /// this class 00431 class Plugin{ 00432 public: 00433 /// return a textual description of the jet-definition implemented 00434 /// in this plugin 00435 virtual std::string description() const = 0; 00436 00437 /// given a ClusterSequence that has been filled up with initial 00438 /// particles, the following function should fill up the rest of the 00439 /// ClusterSequence, using the following member functions of 00440 /// ClusterSequence: 00441 /// - plugin_do_ij_recombination(...) 00442 /// - plugin_do_iB_recombination(...) 00443 virtual void run_clustering(ClusterSequence &) const = 0; 00444 00445 virtual double R() const = 0; 00446 00447 /// return true if there is specific support for the measurement 00448 /// of passive areas, in the sense that areas determined from all 00449 /// particles below the ghost separation scale will be a passive 00450 /// area. [If you don't understand this, ignore it!] 00451 virtual bool supports_ghosted_passive_areas() const {return false;} 00452 00453 /// set the ghost separation scale for passive area determinations 00454 /// in future runs (strictly speaking that makes the routine 00455 /// a non const, so related internal info must be stored as a mutable) 00456 virtual void set_ghost_separation_scale(double scale) const; 00457 virtual double ghost_separation_scale() const {return 0.0;} 00458 00459 /// if this returns false then a warning will be given 00460 /// whenever the user requests "exclusive" jets from the 00461 /// cluster sequence 00462 virtual bool exclusive_sequence_meaningful() const {return false;} 00463 00464 /// a destructor to be replaced if necessary in derived classes... 00465 virtual ~Plugin() {}; 00466 }; 00467 00468 private: 00469 00470 00471 JetAlgorithm _jet_algorithm; 00472 double _Rparam; 00473 double _extra_param ; ///< parameter whose meaning varies according to context 00474 Strategy _strategy ; 00475 00476 const Plugin * _plugin; 00477 SharedPtr<const Plugin> _plugin_shared; 00478 00479 // when we use our own recombiner it's useful to point to it here 00480 // so that we don't have to worry about deleting it etc... 00481 DefaultRecombiner _default_recombiner; 00482 const Recombiner * _recombiner; 00483 SharedPtr<const Recombiner> _recombiner_shared; 00484 00485 }; 00486 00487 00488 //------------------------------------------------------------------------------- 00489 // helper functions to build a jet made of pieces 00490 // 00491 // These functions include an options recombiner used to compute the 00492 // total composite jet momentum 00493 // ------------------------------------------------------------------------------- 00494 00495 /// build a "CompositeJet" from the vector of its pieces 00496 /// 00497 /// In this case, E-scheme recombination is assumed to compute the 00498 /// total momentum 00499 PseudoJet join(const std::vector<PseudoJet> & pieces, const JetDefinition::Recombiner & recombiner); 00500 00501 /// build a MergedJet from a single PseudoJet 00502 PseudoJet join(const PseudoJet & j1, 00503 const JetDefinition::Recombiner & recombiner); 00504 00505 /// build a MergedJet from 2 PseudoJet 00506 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2, 00507 const JetDefinition::Recombiner & recombiner); 00508 00509 /// build a MergedJet from 3 PseudoJet 00510 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2, const PseudoJet & j3, 00511 const JetDefinition::Recombiner & recombiner); 00512 00513 /// build a MergedJet from 4 PseudoJet 00514 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2, const PseudoJet & j3, const PseudoJet & j4, 00515 const JetDefinition::Recombiner & recombiner); 00516 00517 00518 00519 00520 00521 FASTJET_END_NAMESPACE 00522 00523 #endif // __FASTJET_JETDEFINITION_HH__