fastjet: fastjet::CDFJetCluPlugin 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:

00060                                                                       {
00061  
00062   // create the physics towers needed by the CDF code
00063   vector<PhysicsTower> towers;
00064   towers.reserve(clust_seq.jets().size());
00065 
00066   // create a map to identify jets (actually just the input particles)...
00067   //map<double,int> jetmap;
00068 
00069   for (unsigned i = 0; i < clust_seq.jets().size(); i++) {
00070     PseudoJet particle(clust_seq.jets()[i]);
00071     //_insert_unique(particle, jetmap);
00072     LorentzVector fourvect(particle.px(), particle.py(),
00073                            particle.pz(), particle.E());
00074     PhysicsTower tower(fourvect);
00075     // add tracking information for later
00076     tower.fjindex = i;
00077     towers.push_back(tower);
00078   }
00079 
00080   // prepare the CDF algorithm
00081   JetCluAlgorithm j(seed_threshold(), cone_radius(), adjacency_cut(),
00082                     max_iterations(), iratch(), overlap_threshold());
00083     
00084   // run the CDF algorithm
00085   std::vector<Cluster> jets;
00086   j.run(towers,jets);
00087 
00088 
00089   // now transfer the jets back into our own structure -- we will
00090   // mimic the cone code with a sequential recombination sequence in
00091   // which the jets are built up by adding one particle at a time
00092 
00093   // NB: with g++-4.0, the reverse iterator code gave problems, so switch
00094   //     to indices instead
00095   //for(vector<Cluster>::const_reverse_iterator jetIter = jets.rbegin(); 
00096   //                                    jetIter != jets.rend(); jetIter++) {
00097   //  const vector<PhysicsTower> & tower_list = jetIter->towerList;
00098   //  int jet_k = jetmap[tower_list[0].fourVector.E];
00099   //
00100   //  int ntow = int(jetIter->towerList.size());
00101 
00102   for(int iCDFjets = jets.size()-1; iCDFjets >= 0; iCDFjets--) {
00103     const vector<PhysicsTower> & tower_list = jets[iCDFjets].towerList;
00104     //int jet_k = jetmap[tower_list[0].fourVector.E];
00105     int jet_k = tower_list[0].fjindex;
00106   
00107     int ntow = int(tower_list.size());
00108     for (int itow = 1; itow < ntow; itow++) {
00109       int jet_i = jet_k;
00110       // retrieve our misappropriated index for the jet
00111       int jet_j;
00112       jet_j = tower_list[itow].fjindex;
00113       //int alt_jet_j = jetmap[tower_list[itow].fourVector.E];
00114       //assert(jet_j == alt_jet_j);
00115       //cout << jet_j << endl;
00116       // safety check
00117       assert (jet_j >= 0 && jet_j < int(towers.size()));
00118       // do a fake recombination step with dij=0
00119       double dij = 0.0;
00120       // JetClu does E-scheme recombination so we can stick with the
00121       // simple option
00122       clust_seq.plugin_record_ij_recombination(jet_i, jet_j, dij, jet_k);
00123       //if (itow != ntow) {
00124       //  clust_seq.plugin_record_ij_recombination(jet_i, jet_j, dij, jet_k);
00125       //} else {
00126       //  clust_seq.plugin_record_ij_recombination(jet_i, jet_j, dij, 
00127       //       PseudoJet(jetIter->fourVector.px,jetIter->fourVector.py,
00128       //                 jetIter->fourVector.pz,jetIter->fourVector.E),
00129       //                                           jet_k);
00130       //}
00131     }
00132   
00133     // NB: put a sensible looking d_iB just to be nice...
00134     double d_iB = clust_seq.jets()[jet_k].perp2();
00135     clust_seq.plugin_record_iB_recombination(jet_k, d_iB);
00136   }
00137 
00138 
00139   // following code is for testing only
00140   //cout << endl;
00141   //for(vector<Cluster>::const_iterator jetIter = jets.begin(); 
00142   //                                    jetIter != jets.end(); jetIter++) {
00143   //  cout << jetIter->fourVector.pt() << " " << jetIter->fourVector.y() << endl;
00144   //}
00145   //cout << "-----------------------------------------------------\n";
00146   //vector<PseudoJet> ourjets(clust_seq.inclusive_jets());
00147   //for (vector<PseudoJet>::const_iterator ourjet = ourjets.begin();
00148   //     ourjet != ourjets.end(); ourjet++) {
00149   //  cout << ourjet->perp() << " " << ourjet->rap() << endl;
00150   //}
00151   //cout << endl;
00152 }


Public Member Functions
	CDFJetCluPlugin (double cone_radius, double overlap_threshold=0.5, double seed_threshold=1.0, int iratch=1)
	a compact constructor
	CDFJetCluPlugin (double seed_threshold, double cone_radius, int adjacency_cut, int max_iterations, int iratch, double overlap_threshold)
	a constructor that looks like the one provided by CDF
double	seed_threshold () const
double	cone_radius () const
int	adjacency_cut () const
int	max_iterations () const
int	iratch () const
double	overlap_threshold () const
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
Private Member Functions
void	_insert_unique (PseudoJet &jet, std::map< double, int > &jetmap) const
	given a jet try inserting its energy into the map -- if that energy entry already exists, modify the jet infinitesimally so as ensure that the jet energy is unique
Private Attributes
double	_seed_threshold
double	_cone_radius
int	_adjacency_cut
int	_max_iterations
int	_iratch
double	_overlap_threshold

fastjet::CDFJetCluPlugin Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation