JetDefinition::DefaultRecombiner Class Reference

A class that will provide the recombination scheme facilities and/or allow a user to extend these facilities. More...

#include <JetDefinition.hh>

Inheritance diagram for JetDefinition::DefaultRecombiner:

[legend]

Collaboration diagram for JetDefinition::DefaultRecombiner:

[legend]

List of all members.

Public Member Functions
	DefaultRecombiner (RecombinationScheme recomb_scheme=E_scheme)
virtual std::string	description () const
	return a textual description of the recombination scheme implemented here
virtual void	recombine (const PseudoJet &pa, const PseudoJet &pb, PseudoJet &pab) const
	recombine pa and pb and put result into pab
virtual void	preprocess (PseudoJet &p) const
	routine called to preprocess each input jet (to make all input jets compatible with the scheme requirements (e.g.
RecombinationScheme	scheme () const
	return the index of the recombination scheme
Private Attributes
RecombinationScheme	_recomb_scheme

Detailed Description

A class that will provide the recombination scheme facilities and/or allow a user to extend these facilities.

Definition at line 357 of file JetDefinition.hh.

Constructor & Destructor Documentation

JetDefinition::DefaultRecombiner::DefaultRecombiner ( RecombinationScheme recomb_scheme = E_scheme ) [inline]

Definition at line 359 of file JetDefinition.hh.

00359                                                                     : 
00360       _recomb_scheme(recomb_scheme) {}

Member Function Documentation

string JetDefinition::DefaultRecombiner::description ( ) const [virtual]

return a textual description of the recombination scheme implemented here

Implements JetDefinition::Recombiner.

Definition at line 134 of file JetDefinition.cc.

References _recomb_scheme, BIpt2_scheme, BIpt_scheme, E_scheme, Et2_scheme, Et_scheme, pt2_scheme, and pt_scheme.

00134                                                          {
00135   switch(_recomb_scheme) {
00136   case E_scheme:
00137     return "E scheme recombination";
00138   case pt_scheme:
00139     return "pt scheme recombination";
00140   case pt2_scheme:
00141     return "pt2 scheme recombination";
00142   case Et_scheme:
00143     return "Et scheme recombination";
00144   case Et2_scheme:
00145     return "Et2 scheme recombination";
00146   case BIpt_scheme:
00147     return "boost-invariant pt scheme recombination";
00148   case BIpt2_scheme:
00149     return "boost-invariant pt2 scheme recombination";
00150   default:
00151     ostringstream err;
00152     err << "DefaultRecombiner: unrecognized recombination scheme " 
00153         << _recomb_scheme;
00154     throw Error(err.str());
00155   }
00156 }

void JetDefinition::DefaultRecombiner::preprocess ( PseudoJet & ) const [virtual]

routine called to preprocess each input jet (to make all input jets compatible with the scheme requirements (e.g.

massless).

Reimplemented from JetDefinition::Recombiner.

Definition at line 212 of file JetDefinition.cc.

References _recomb_scheme, BIpt2_scheme, BIpt_scheme, PseudoJet::E(), E_scheme, Et2_scheme, Et_scheme, PseudoJet::perp2(), pt2_scheme, pt_scheme, PseudoJet::px(), PseudoJet::py(), PseudoJet::pz(), PseudoJet::set_user_index(), and PseudoJet::user_index().

Referenced by fastjet::TrackJetPlugin::run_clustering().

00212                                                                    {
00213   switch(_recomb_scheme) {
00214   case E_scheme:
00215   case BIpt_scheme:
00216   case BIpt2_scheme:
00217     break;
00218   case pt_scheme:
00219   case pt2_scheme:
00220     {
00221       // these schemes (as in the ktjet implementation) need massless
00222       // initial 4-vectors with essentially E=|p|.
00223       double newE = sqrt(p.perp2()+p.pz()*p.pz());
00224       int    user_index = p.user_index();
00225       p = PseudoJet(p.px(), p.py(), p.pz(), newE);
00226       p.set_user_index(user_index);
00227     }
00228     break;
00229   case Et_scheme:
00230   case Et2_scheme:
00231     {
00232       // these schemes (as in the ktjet implementation) need massless
00233       // initial 4-vectors with essentially E=|p|.
00234       double rescale = p.E()/sqrt(p.perp2()+p.pz()*p.pz());
00235       int    user_index = p.user_index();
00236       p = PseudoJet(rescale*p.px(), rescale*p.py(), rescale*p.pz(), p.E());
00237       p.set_user_index(user_index);
00238     }
00239     break;
00240   default:
00241     ostringstream err;
00242     err << "DefaultRecombiner: unrecognized recombination scheme " 
00243         << _recomb_scheme;
00244     throw Error(err.str());
00245   }
00246 }

void JetDefinition::DefaultRecombiner::recombine	(	const PseudoJet &	pa,
		const PseudoJet &	pb,
		PseudoJet &	pab
	)			const `[virtual]`

recombine pa and pb and put result into pab

Implements JetDefinition::Recombiner.

Definition at line 159 of file JetDefinition.cc.

References _recomb_scheme, BIpt2_scheme, BIpt_scheme, E_scheme, Et2_scheme, Et_scheme, PseudoJet::perp(), PseudoJet::perp2(), PseudoJet::phi(), fastjet::pi, pt2_scheme, pt_scheme, PseudoJet::rap(), PseudoJet::set_user_index(), and twopi.

Referenced by fastjet::TrackJetPlugin::run_clustering().

00161                                   {
00162   
00163   double weighta, weightb;
00164 
00165   switch(_recomb_scheme) {
00166   case E_scheme:
00167     pab = pa + pb; 
00168     pab.set_user_index(0);
00169     return;
00170   // all remaining schemes are massless recombinations and locally
00171   // we just set weights, while the hard work is done below...
00172   case pt_scheme:
00173   case Et_scheme:
00174   case BIpt_scheme:
00175     weighta = pa.perp(); 
00176     weightb = pb.perp();
00177     break;
00178   case pt2_scheme:
00179   case Et2_scheme:
00180   case BIpt2_scheme:
00181     weighta = pa.perp2(); 
00182     weightb = pb.perp2();
00183     break;
00184   default:
00185     ostringstream err;
00186     err << "DefaultRecombiner: unrecognized recombination scheme " 
00187         << _recomb_scheme;
00188     throw Error(err.str());
00189   }
00190 
00191   double perp_ab = pa.perp() + pb.perp();
00192   if (perp_ab != 0.0) { // weights also non-zero...
00193     double y_ab    = (weighta * pa.rap() + weightb * pb.rap())/(weighta+weightb);
00194     
00195     // take care with periodicity in phi...
00196     double phi_a = pa.phi(), phi_b = pb.phi();
00197     if (phi_a - phi_b > pi)  phi_b += twopi;
00198     if (phi_a - phi_b < -pi) phi_b -= twopi;
00199     double phi_ab = (weighta * phi_a + weightb * phi_b)/(weighta+weightb);
00200     
00201     pab = PseudoJet(perp_ab*cos(phi_ab),
00202                     perp_ab*sin(phi_ab),
00203                     perp_ab*sinh(y_ab),
00204                     perp_ab*cosh(y_ab));
00205   } else { // weights are zero
00206     pab = PseudoJet(0.0,0.0,0.0,0.0);
00207   }
00208   pab.set_user_index(0);
00209 }