fastjet::PxConePlugin Class Reference

PxConePlugin is a plugin for fastjet (v2.1 upwards) that provides an interface to the fortran pxcone iterative cone algorithm with midpoint seeds. More...

#include <PxConePlugin.hh>

Inheritance diagram for fastjet::PxConePlugin:

[legend]

Collaboration diagram for fastjet::PxConePlugin:

[legend]

List of all members.

Public Member Functions
	PxConePlugin (double cone_radius, double min_jet_energy=5.0, double overlap_threshold=0.5, bool E_scheme_jets=false)
	constructor for the PxConePlugin, whose arguments have the following meaning:
double	cone_radius () const
	the cone radius
double	min_jet_energy () const
	minimum jet energy (protojets below this are thrown own before merging/splitting) -- called epslon in pxcone
double	overlap_threshold () const
	Maximum fraction of overlap energy in a jet -- called ovlim in pxcone.
bool	E_scheme_jets () const
	if true then the final jets are returned as the E-scheme recombination of the particle momenta (by default, pxcone returns massless jets with a mean phi,eta type of recombination); regardless of what is returned, the internal pxcone jet-finding procedure is unaffected.
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 Attributes
double	_cone_radius
double	_min_jet_energy
double	_overlap_threshold
bool	_E_scheme_jets

Detailed Description

PxConePlugin is a plugin for fastjet (v2.1 upwards) that provides an interface to the fortran pxcone iterative cone algorithm with midpoint seeds.

Pxcone was written by Luis del Pozo and Michael H. Seymour. It is not a "supported" program, so if you encounter problems, you are on your own...

Note that pxcone sometimes encounters non-stable iterations; in such cases it returns an error -- the plugin propagates this by throwing a fastjet::Error exception; if the user wishes to have robust code, they should catch this exception.

Pxcone has a hard-coded limit (by default 4000) on the maximum number of particles and protojets; if the number of particles or protojets exceeds this, again a fastjet::Error exception will be thrown.

The functionality of pxcone is described at http://www.hep.man.ac.uk/u/wplano/ConeJet.ps

Definition at line 65 of file PxConePlugin.hh.

Constructor & Destructor Documentation

fastjet::PxConePlugin::PxConePlugin	(	double	cone_radius,
		double	min_jet_energy = `5.0`,
		double	overlap_threshold = `0.5`,
		bool	E_scheme_jets = `false`
	)			`[inline]`

constructor for the PxConePlugin, whose arguments have the following meaning:

the cone_radius is as usual in cone algorithms

stables cones (protojets) below min_jet_energy are discarded before calling the splitting procedure to resolve overlaps (called epslon in pxcone).

when two protojets overlap, if (overlapping_Et)/(Et_of_softer_protojet) < overlap_threshold the overlapping energy is split between the two protojets; otherwise the less energetic protojet is discarded. Called ovlim in pxcone.

pxcone carries out p-scheme recombination, and the resulting jets are massless; setting E_scheme_jets = true (default false) doesn't change the jet composition, but the final momentum sum for the jets is carried out by direct four-vector addition instead of p-scheme recombination.

Definition at line 89 of file PxConePlugin.hh.

00092                                                : 
00093     _cone_radius        (cone_radius        ),
00094     _min_jet_energy     (min_jet_energy     ),
00095     _overlap_threshold  (overlap_threshold  ),
00096     _E_scheme_jets      (E_scheme_jets      ) {}

Member Function Documentation

double fastjet::PxConePlugin::cone_radius ( ) const [inline]

the cone radius

Definition at line 102 of file PxConePlugin.hh.

Referenced by description(), and run_clustering().

00102 {return _cone_radius        ;}

string fastjet::PxConePlugin::description ( ) const [virtual]

return a textual description of the jet-definition implemented in this plugin

Implements JetDefinition::Plugin.

Definition at line 44 of file PxConePlugin.cc.

References cone_radius(), E_scheme_jets(), min_jet_energy(), and overlap_threshold().

00044                                         {
00045   ostringstream desc;
00046   
00047   desc << "PxCone jet algorithm with " 
00048        << "cone_radius = "        << cone_radius        () << ", "
00049        << "min_jet_energy = "     << min_jet_energy     () << ", "
00050        << "overlap_threshold  = " << overlap_threshold  () << ", "
00051        << "E_scheme_jets  = "     << E_scheme_jets      () 
00052        << " (NB: non-standard version of PxCone, containing small bug fixes by Gavin Salam)";
00053 
00054   return desc.str();
00055 }

bool fastjet::PxConePlugin::E_scheme_jets ( ) const [inline]

if true then the final jets are returned as the E-scheme recombination of the particle momenta (by default, pxcone returns massless jets with a mean phi,eta type of recombination); regardless of what is returned, the internal pxcone jet-finding procedure is unaffected.

Definition at line 116 of file PxConePlugin.hh.

Referenced by description(), and run_clustering().

00116 {return _E_scheme_jets      ;}

double fastjet::PxConePlugin::min_jet_energy ( ) const [inline]

minimum jet energy (protojets below this are thrown own before merging/splitting) -- called epslon in pxcone

Definition at line 106 of file PxConePlugin.hh.

Referenced by description(), and run_clustering().

00106 {return _min_jet_energy     ;}

double fastjet::PxConePlugin::overlap_threshold ( ) const [inline]

Maximum fraction of overlap energy in a jet -- called ovlim in pxcone.

Definition at line 109 of file PxConePlugin.hh.

Referenced by description(), and run_clustering().

00109 {return _overlap_threshold  ;}

virtual double fastjet::PxConePlugin::R ( ) const [inline, virtual]

the plugin mechanism's standard way of accessing the jet radius

Implements JetDefinition::Plugin.

Definition at line 123 of file PxConePlugin.hh.

00123 {return cone_radius();}

void fastjet::PxConePlugin::run_clustering ( ClusterSequence & ) const [virtual]

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(.

..)

plugin_do_iB_recombination(...)

Implements JetDefinition::Plugin.

Definition at line 58 of file PxConePlugin.cc.

References cone_radius(), E_scheme_jets(), ClusterSequence::jets(), min_jet_energy(), overlap_threshold(), ClusterSequence::plugin_record_iB_recombination(), ClusterSequence::plugin_record_ij_recombination(), and pxcone.

00058                                                                    {
00059  
00060   // only have hh mode
00061   int mode = 2;
00062 
00063   int    ntrak = clust_seq.jets().size(), itkdm = 4;
00064   double *ptrak = new double[ntrak*4+1];
00065   for (int i = 0; i < ntrak; i++) {
00066     ptrak[4*i+0] = clust_seq.jets()[i].px();
00067     ptrak[4*i+1] = clust_seq.jets()[i].py();
00068     ptrak[4*i+2] = clust_seq.jets()[i].pz();
00069     ptrak[4*i+3] = clust_seq.jets()[i].E();
00070   }  
00071 
00072   // max number of allowed jets
00073   int mxjet = ntrak;
00074   int njet;
00075   double *pjet  = new double[mxjet*5+1];
00076   int    *ipass = new int[ntrak+1];
00077   int    *ijmul = new int[mxjet+1];
00078   int ierr;
00079 
00080   // run pxcone
00081   pxcone(
00082     mode   ,    // 1=>e+e-, 2=>hadron-hadron
00083     ntrak  ,    // Number of particles
00084     itkdm  ,    // First dimension of PTRAK array: 
00085     ptrak  ,    // Array of particle 4-momenta (Px,Py,Pz,E)
00086     cone_radius()  ,    // Cone size (half angle) in radians
00087     min_jet_energy() ,    // Minimum Jet energy (GeV)
00088     overlap_threshold()  ,    // Maximum fraction of overlap energy in a jet
00089     mxjet  ,    // Maximum possible number of jets
00090     njet   ,    // Number of jets found
00091     pjet ,       // 5-vectors of jets
00092     ipass,      // Particle k belongs to jet number IPASS(k)-1
00093                 // IPASS = -1 if not assosciated to a jet
00094     ijmul,      // Jet i contains IJMUL[i] particles
00095     ierr        // = 0 if all is OK ;   = -1 otherwise
00096     );
00097 
00098   if (ierr != 0) throw Error("An error occurred while running PXCONE");
00099 
00100   // now transfer information back 
00101   valarray<int> last_index_created(njet);
00102 
00103   vector<vector<int> > jet_particle_content(njet);
00104 
00105   // get a list of particles in each jet
00106   for (int itrak = 0; itrak < ntrak; itrak++) {
00107     int jet_i = ipass[itrak] - 1;
00108     if (jet_i >= 0) jet_particle_content[jet_i].push_back(itrak);
00109   }
00110 
00111   // now transfer the jets back into our own structure -- we will
00112   // mimic the cone code with a sequential recombination sequence in
00113   // which the jets are built up by adding one particle at a time
00114   for(int ipxjet = njet-1; ipxjet >= 0; ipxjet--) {
00115     const vector<int> & jet_trak_list = jet_particle_content[ipxjet];
00116     int jet_k = jet_trak_list[0];
00117   
00118     for (unsigned ilist = 1; ilist < jet_trak_list.size(); ilist++) {
00119       int jet_i = jet_k;
00120       // retrieve our misappropriated index for the jet
00121       int jet_j = jet_trak_list[ilist];
00122       // do a fake recombination step with dij=0
00123       double dij = 0.0;
00124       //clust_seq.plugin_record_ij_recombination(jet_i, jet_j, dij, jet_k);
00125       if (ilist != jet_trak_list.size()-1 || E_scheme_jets()) {
00126         // our E-scheme recombination in cases where it doesn't matter
00127         clust_seq.plugin_record_ij_recombination(jet_i, jet_j, dij, jet_k);
00128       } else {
00129         // put in pxcone's momentum for the last recombination so that the
00130         // final inclusive jet corresponds exactly to PXCONE's
00131         clust_seq.plugin_record_ij_recombination(jet_i, jet_j, dij, 
00132                                 PseudoJet(pjet[5*ipxjet+0],pjet[5*ipxjet+1],
00133                                           pjet[5*ipxjet+2],pjet[5*ipxjet+3]),
00134                                                  jet_k);
00135       }
00136     }
00137   
00138     // NB: put a sensible looking d_iB just to be nice...
00139     double d_iB = clust_seq.jets()[jet_k].perp2();
00140     clust_seq.plugin_record_iB_recombination(jet_k, d_iB);
00141   }
00142 
00143 
00145   //cout << endl;
00146   //for (int ijet = 0; ijet < njet; ijet++) {
00147   //  PseudoJet jet(pjet[ijet][0],pjet[ijet][1],pjet[ijet][2],pjet[ijet][3]);
00148   //  cout << jet.perp() << " " << jet.rap() << endl;
00149   //}
00150   //cout << "-----------------------------------------------------\n";
00151   //vector<PseudoJet> ourjets(clust_seq.inclusive_jets());
00152   //for (vector<PseudoJet>::const_iterator ourjet = ourjets.begin();
00153   //     ourjet != ourjets.end(); ourjet++) {
00154   //  cout << ourjet->perp() << " " << ourjet->rap() << endl;
00155   //}
00157 
00158   delete[] ptrak;
00159   delete[] ipass;
00160   delete[] ijmul;
00161   delete[] pjet;
00162 }

Member Data Documentation

double fastjet::PxConePlugin::_cone_radius [private]

Definition at line 127 of file PxConePlugin.hh.

bool fastjet::PxConePlugin::_E_scheme_jets [private]

Definition at line 131 of file PxConePlugin.hh.

double fastjet::PxConePlugin::_min_jet_energy [private]

Definition at line 128 of file PxConePlugin.hh.

double fastjet::PxConePlugin::_overlap_threshold [private]

Definition at line 129 of file PxConePlugin.hh.

The documentation for this class was generated from the following files:

plugins/PxCone/fastjet/PxConePlugin.hh
plugins/PxCone/PxConePlugin.cc

fastjet::PxConePlugin Class Reference

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation