fastjet: fastjet::SISConePlugin Class Reference

given a ClusterSequence that has been filled up with initial particles, the following function should fill up the rest of the ClusterSequence, using the following member functions of ClusterSequence:

00061                                                                     {
00062 
00063 
00064   Csiscone * siscone;
00065   Csiscone   local_siscone;
00066 
00067   unsigned n = clust_seq.jets().size();
00068 
00069   bool new_siscone = true; // by default we'll be running it
00070 
00071   if (caching()) {
00072 
00073     // Establish if we have a cached run with the same R, npass and
00074     // particles. If not then do any tidying up / reallocation that's
00075     // necessary for the next round of caching, otherwise just set
00076     // relevant pointers so that we can reuse and old run.
00077     if (stored_siscone.get() != 0) {
00078       new_siscone = !(stored_plugin->cone_radius()   == cone_radius()
00079                       && stored_plugin->n_pass_max() == n_pass_max()  
00080                       && stored_particles->size()    == n);
00081       if (!new_siscone) {
00082         for(unsigned i = 0; i < n; i++) {
00083           // only check momentum because indices will be correctly dealt
00084           // with anyway when extracting the clustering order.
00085           new_siscone |= !have_same_momentum(clust_seq.jets()[i], 
00086                                              (*stored_particles)[i]);
00087         }
00088       }
00089     } 
00090       
00091     // allocate the new siscone, etc., if need be
00092     if (new_siscone) {
00093       stored_siscone  .reset( new Csiscone                           );
00094       stored_particles.reset( new vector<PseudoJet>(clust_seq.jets()));
00095       stored_plugin   .reset( new SISConePlugin(*this)               );
00096     }
00097 
00098     siscone = stored_siscone.get();
00099   } else {
00100     siscone = &local_siscone;
00101   }
00102 
00103   // make sure stopping scale is set in siscone
00104   siscone->SM_var2_hardest_cut_off = _split_merge_stopping_scale*_split_merge_stopping_scale;
00105   // when running with ghosts for passive areas, do not put the
00106   // ghosts into the stable-cone search (not relevant)
00107   siscone->stable_cone_soft_pt2_cutoff = ghost_separation_scale()
00108                                          * ghost_separation_scale();
00109 
00110   if (new_siscone) {
00111     // transfer fastjet initial particles into the siscone type
00112     vector<Cmomentum> siscone_momenta(n);
00113     for(unsigned i = 0; i < n; i++) {
00114       const PseudoJet & p = clust_seq.jets()[i]; // shorthand
00115       siscone_momenta[i] = Cmomentum(p.px(), p.py(), p.pz(), p.E());
00116     }
00117     
00118     // run the jet finding
00119     //cout << "plg sms: " << split_merge_scale() << endl;
00120     siscone->compute_jets(siscone_momenta, cone_radius(), overlap_threshold(),
00121                           n_pass_max(), protojet_or_ghost_ptmin(), 
00122                           Esplit_merge_scale(split_merge_scale()));
00123   } else {
00124     // just run the overlap part of the jets.
00125     //cout << "plg rcmp sms: " << split_merge_scale() << endl;
00126     siscone->recompute_jets(overlap_threshold(), protojet_or_ghost_ptmin(), 
00127                             Esplit_merge_scale(split_merge_scale()));
00128   }
00129 
00130   // extract the jets [in reverse order -- to get nice ordering in pt at end]
00131   int njet = siscone->jets.size();
00132 
00133   for (int ijet = njet-1; ijet >= 0; ijet--) {
00134     const Cjet & jet = siscone->jets[ijet]; // shorthand
00135     
00136     // Successively merge the particles that make up the cone jet
00137     // until we have all particles in it.  Start off with the zeroth
00138     // particle.
00139     int jet_k = jet.contents[0];
00140     for (unsigned ipart = 1; ipart < jet.contents.size(); ipart++) {
00141       // take the last result of the merge
00142       int jet_i = jet_k;
00143       // and the next element of the jet
00144       int jet_j = jet.contents[ipart];
00145       // and merge them (with a fake dij)
00146       double dij = 0.0;
00147 
00148       // create the new jet by hand so that we can adjust its user index
00149       PseudoJet newjet = clust_seq.jets()[jet_i] + clust_seq.jets()[jet_j];
00150 
00151       // set the user index to be the pass in which the jet was discovered
00152       newjet.set_user_index(jet.pass);
00153         
00154       clust_seq.plugin_record_ij_recombination(jet_i, jet_j, dij, newjet, jet_k);
00155     }
00156     // we have merged all the jet's particles into a single object, so now
00157     // "declare" it to be a beam (inclusive) jet.
00158     // [NB: put a sensible looking d_iB just to be nice...]
00159     double d_iB = clust_seq.jets()[jet_k].perp2();
00160     clust_seq.plugin_record_iB_recombination(jet_k, d_iB);
00161   }
00162 
00163   // now copy the list of protocones into an "extras" objects
00164   SISConeExtras * extras = new SISConeExtras;
00165   for (unsigned ipass = 0; ipass < siscone->protocones_list.size(); ipass++) {
00166     for (unsigned ipc = 0; ipc < siscone->protocones_list[ipass].size(); ipc++) {
00167       double rap = siscone->protocones_list[ipass][ipc].eta;
00168       double phi = siscone->protocones_list[ipass][ipc].phi;
00169       PseudoJet protocone(cos(phi),sin(phi),sinh(rap),cosh(rap));
00170       //PseudoJet protocone(siscone->protocones_list[ipass][ipc]);
00171       protocone.set_user_index(ipass);
00172       extras->_protocones.push_back(protocone);
00173     }
00174   }
00175   extras->_most_ambiguous_split = siscone->most_ambiguous_split;
00176 
00177   // tell it what the jet definition was
00178   extras->_jet_def_plugin = this;
00179 
00180   // give the extras object to the cluster sequence.
00181   clust_seq.plugin_associate_extras(auto_ptr<ClusterSequence::Extras>(extras));
00182 }


Public Types
enum	SplitMergeScale { SM_pt, SM_Et, SM_mt, SM_pttilde }
	enum for the different split-merge scale choices; Note that order _must_ be the same as in siscone More...
Public Member Functions
	SISConePlugin (double cone_radius, double overlap_threshold=0.5, int n_pass_max=0, double protojet_ptmin=0.0, bool caching=false, SplitMergeScale split_merge_scale=SM_pttilde, double split_merge_stopping_scale=0.0)
	Constructor for the SISCone Plugin class.
	SISConePlugin (double cone_radius, double overlap_threshold, int n_pass_max, double protojet_ptmin, bool caching, bool split_merge_on_transverse_mass)
	Backwards compatible constructor for the SISCone Plugin class.
	SISConePlugin (double cone_radius, double overlap_threshold, int n_pass_max, bool caching)
	backwards compatible constructor for the SISCone Plugin class (avoid using this in future).
	SISConePlugin (const SISConePlugin &plugin)
	copy constructor
double	cone_radius () const
	the cone radius
double	overlap_threshold () const
	Fraction of overlap energy in a jet above which jets are merged and below which jets are split.
int	n_pass_max () const
	the maximum number of passes of stable-cone searching (<=0 is same as infinity).
double	protojet_ptmin () const
	minimum pt for a protojet to be considered in the split-merge step of the algorithm
double	protojet_or_ghost_ptmin () const
	return the scale to be passed to SISCone as the protojet_ptmin -- if we have a ghost separation scale that is above the protojet_ptmin, then the ghost_separation_scale becomes the relevant one to use here
SplitMergeScale	split_merge_scale () const
	indicates scale used in split-merge
void	set_split_merge_scale (SplitMergeScale sms)
	sets scale used in split-merge
bool	split_merge_on_transverse_mass () const
	indicates whether the split-merge orders on transverse mass or not.
void	set_split_merge_on_transverse_mass (bool val)
void	set_split_merge_stopping_scale (double scale)
	set the "split_merge_stopping_scale": if the scale variable for all protojets is below this, then stop the split-merge procedure and keep only those jets found so far.
double	split_merge_stopping_scale ()
	return the value of the split_merge_stopping_scale (see set_split_merge_stopping_scale(.
bool	caching () const
	indicates whether caching is turned on or not.
virtual std::string	description () const
	return a textual description of the jet-definition implemented in this plugin
virtual void	run_clustering (ClusterSequence &) const
	given a ClusterSequence that has been filled up with initial particles, the following function should fill up the rest of the ClusterSequence, using the following member functions of ClusterSequence: plugin_do_ij_recombination(.
virtual double	R () const
	the plugin mechanism's standard way of accessing the jet radius
virtual bool	supports_ghosted_passive_areas () const
	return true since there is specific support for the measurement of passive areas, in the sense that areas determined from all particles below the ghost separation scale will be a passive area.
virtual void	set_ghost_separation_scale (double scale) const
	set the ghost separation scale for passive area determinations _just_ in the next run (strictly speaking that makes the routine a non const, so related internal info must be stored as a mutable)
virtual double	ghost_separation_scale () const
Private Attributes
double	_cone_radius
double	_overlap_threshold
int	_n_pass_max
double	_protojet_ptmin
bool	_caching
SplitMergeScale	_split_merge_scale
double	_split_merge_stopping_scale
double	_ghost_sep_scale
Static Private Attributes
static std::auto_ptr< SISConePlugin >	stored_plugin
static std::auto_ptr< std::vector< PseudoJet > >	stored_particles
static std::auto_ptr< siscone::Csiscone >	stored_siscone

fastjet::SISConePlugin Class Reference

Public Types

Public Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation