FastJet 3.0.2
|
00001 #ifndef __SISCONEPLUGIN_HH__ 00002 #define __SISCONEPLUGIN_HH__ 00003 00004 #include "SISConeBasePlugin.hh" 00005 00006 // forward declaration of the siscone classes we'll need 00007 namespace siscone{ 00008 class Csiscone; 00009 } 00010 00011 00012 FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh 00013 00014 //---------------------------------------------------------------------- 00015 // 00016 /// @ingroup plugins 00017 /// \class SISConePlugin 00018 /// Implementation of the SISCone algorithm (plugin for fastjet v2.1 upwards) 00019 /// 00020 /// SISConePlugin is a plugin for fastjet (v2.1 upwards) that provides 00021 /// an interface to the seedless infrared safe cone jet finder by 00022 /// Gregory Soyez and Gavin Salam. 00023 /// 00024 /// SISCone uses geometrical techniques to exhaustively consider all 00025 /// possible distinct cones. It then finds out which ones are stable 00026 /// and sends the result to the Tevatron Run-II type split-merge 00027 /// procedure for overlapping cones. 00028 /// 00029 /// Four parameters govern the "physics" of the algorithm: 00030 /// 00031 /// - the cone_radius (this should be self-explanatory!) 00032 /// 00033 /// - the overlap_threshold is the parameter which dictates how much 00034 /// two jets must overlap (pt_overlap/min(pt1,pt2)) if they are to be 00035 /// merged 00036 /// 00037 /// - Not all particles are in stable cones in the first round of 00038 /// searching for stable cones; one can therefore optionally have the 00039 /// the jet finder carry out additional passes of searching for 00040 /// stable cones among particles that were in no stable cone in 00041 /// previous passes --- the maximum number of passes carried out is 00042 /// n_pass_max. If this is zero then additional passes are carried 00043 /// out until no new stable cones are found. 00044 /// 00045 /// - Protojet ptmin: protojets that are below this ptmin 00046 /// (default = 0) are discarded before each iteration of the 00047 /// split-merge loop. 00048 /// 00049 /// One parameter governs some internal algorithmic shortcuts: 00050 /// 00051 /// - if "caching" is turned on then the last event clustered by 00052 /// siscone is stored -- if the current event is identical and the 00053 /// cone_radius and n_pass_mass are identical, then the only part of 00054 /// the clustering that needs to be rerun is the split-merge part, 00055 /// leading to significant speed gains; there is a small (O(N) storage 00056 /// and speed) penalty for caching, so it should be kept off 00057 /// (default) if only a single overlap_threshold is used. 00058 /// 00059 /// The final jets can be accessed by requestion the 00060 /// inclusive_jets(...) from the ClusterSequence object. Note that 00061 /// these PseudoJets have their user_index() set to the index of the 00062 /// pass in which they were found (first pass = 0). NB: This does not 00063 /// currently work for jets that consist of a single particle. 00064 /// 00065 /// For further information on the details of the algorithm see the 00066 /// SISCone paper, arXiv:0704.0292 [JHEP 0705:086,2007]. 00067 /// 00068 /// For documentation about the implementation, see the 00069 /// siscone/doc/html/index.html file. 00070 // 00071 class SISConePlugin : public SISConeBasePlugin{ 00072 public: 00073 00074 /// enum for the different split-merge scale choices; 00075 /// Note that order _must_ be the same as in siscone 00076 enum SplitMergeScale {SM_pt, ///< transverse momentum (E-scheme), IR unsafe 00077 SM_Et, ///< transverse energy (E-scheme), not long. boost invariant 00078 ///< original run-II choice [may not be implemented] 00079 SM_mt, ///< transverse mass (E-scheme), IR safe except 00080 ///< in decays of two identical narrow heavy particles 00081 SM_pttilde ///< pt-scheme pt = \sum_{i in jet} |p_{ti}|, should 00082 ///< be IR safe in all cases 00083 }; 00084 00085 00086 /// Main constructor for the SISCone Plugin class. 00087 /// 00088 /// Note: wrt version prior to 2.4 this constructor differs in that a 00089 /// the default value has been removed for overlap_threshold. The 00090 /// former has been removed because the old default of 0.5 was found 00091 /// to be unsuitable in high-noise environments; so the user should 00092 /// now explicitly think about the value for this -- we recommend 00093 /// 0.75. 00094 /// 00095 SISConePlugin (double cone_radius_in, 00096 double overlap_threshold_in, 00097 int n_pass_max_in = 0, 00098 double protojet_ptmin_in = 0.0, 00099 bool caching_in = false, 00100 SplitMergeScale split_merge_scale_in = SM_pttilde, 00101 double split_merge_stopping_scale_in = 0.0){ 00102 _cone_radius = cone_radius_in; 00103 _overlap_threshold = overlap_threshold_in; 00104 _n_pass_max = n_pass_max_in; 00105 _protojet_ptmin = protojet_ptmin_in; 00106 _caching = caching_in; 00107 _split_merge_scale = split_merge_scale_in; 00108 _split_merge_stopping_scale = split_merge_stopping_scale_in; 00109 _ghost_sep_scale = 0.0; 00110 _use_pt_weighted_splitting = false;} 00111 00112 00113 /// Backwards compatible constructor for the SISCone Plugin class 00114 SISConePlugin (double cone_radius_in, 00115 double overlap_threshold_in, 00116 int n_pass_max_in, 00117 double protojet_ptmin_in, 00118 bool caching_in, 00119 bool split_merge_on_transverse_mass_in){ 00120 _cone_radius = cone_radius_in; 00121 _overlap_threshold = overlap_threshold_in; 00122 _n_pass_max = n_pass_max_in; 00123 _protojet_ptmin = protojet_ptmin_in; 00124 _caching = caching_in; 00125 _split_merge_stopping_scale = 0.0; 00126 _split_merge_scale = split_merge_on_transverse_mass_in ? SM_mt : SM_pttilde; 00127 _ghost_sep_scale = 0.0;} 00128 00129 /// backwards compatible constructor for the SISCone Plugin class 00130 /// (avoid using this in future). 00131 SISConePlugin (double cone_radius_in, 00132 double overlap_threshold_in, 00133 int n_pass_max_in, 00134 bool caching_in) { 00135 _cone_radius = cone_radius_in; 00136 _overlap_threshold = overlap_threshold_in; 00137 _n_pass_max = n_pass_max_in; 00138 _protojet_ptmin = 0.0; 00139 _caching = caching_in; 00140 _split_merge_scale = SM_mt; 00141 _split_merge_stopping_scale = 0.0; 00142 _ghost_sep_scale = 0.0; 00143 _use_pt_weighted_splitting = false;} 00144 00145 /// minimum pt for a protojet to be considered in the split-merge step 00146 /// of the algorithm 00147 double protojet_ptmin () const {return _protojet_ptmin ;} 00148 00149 /// return the scale to be passed to SISCone as the protojet_ptmin 00150 /// -- if we have a ghost separation scale that is above the 00151 /// protojet_ptmin, then the ghost_separation_scale becomes the 00152 /// relevant one to use here 00153 double protojet_or_ghost_ptmin () const {return std::max(_protojet_ptmin, 00154 _ghost_sep_scale);} 00155 00156 /// indicates scale used in split-merge 00157 SplitMergeScale split_merge_scale() const {return _split_merge_scale;} 00158 /// sets scale used in split-merge 00159 void set_split_merge_scale(SplitMergeScale sms) {_split_merge_scale = sms;} 00160 00161 /// indicates whether the split-merge orders on transverse mass or not. 00162 /// retained for backwards compatibility with 2.1.0b3 00163 bool split_merge_on_transverse_mass() const {return _split_merge_scale == SM_mt ;} 00164 void set_split_merge_on_transverse_mass(bool val) { 00165 _split_merge_scale = val ? SM_mt : SM_pt;} 00166 00167 /// indicates whether the split-merge orders on transverse mass or not. 00168 /// retained for backwards compatibility with 2.1.0b3 00169 bool split_merge_use_pt_weighted_splitting() const {return _use_pt_weighted_splitting;} 00170 void set_split_merge_use_pt_weighted_splitting(bool val) { 00171 _use_pt_weighted_splitting = val;} 00172 00173 // the things that are required by base class 00174 virtual std::string description () const; 00175 virtual void run_clustering(ClusterSequence &) const ; 00176 00177 protected: 00178 virtual void reset_stored_plugin() const; 00179 00180 private: 00181 double _protojet_ptmin; 00182 SplitMergeScale _split_merge_scale; 00183 00184 bool _use_pt_weighted_splitting; 00185 00186 // part needed for the cache 00187 // variables for caching the results and the input 00188 static std::auto_ptr<SISConePlugin > stored_plugin; 00189 static std::auto_ptr<std::vector<PseudoJet> > stored_particles; 00190 static std::auto_ptr<siscone::Csiscone > stored_siscone; 00191 }; 00192 00193 00194 //====================================================================== 00195 /// @ingroup extra_info 00196 /// \class SISConeExtras 00197 /// Class that provides extra information about a SISCone clustering 00198 class SISConeExtras : public SISConeBaseExtras { 00199 public: 00200 /// constructor 00201 // it just initialises the pass information 00202 SISConeExtras(int nparticles) 00203 : SISConeBaseExtras(nparticles){} 00204 00205 /// access to the siscone jet def plugin (more convenient than 00206 /// getting it from the original jet definition, because here it's 00207 /// directly of the right type (rather than the base type) 00208 const SISConePlugin* jet_def_plugin() const { 00209 return dynamic_cast<const SISConePlugin*>(_jet_def_plugin); 00210 } 00211 00212 private: 00213 // let us be written to by SISConePlugin 00214 friend class SISConePlugin; 00215 }; 00216 00217 FASTJET_END_NAMESPACE // defined in fastjet/internal/base.hh 00218 00219 #endif // __SISCONEPLUGIN_HH__ 00220