Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members

JetDefinition.cc

Go to the documentation of this file.
00001 #include "fastjet/JetDefinition.hh"
00002 #include "fastjet/Error.hh"
00003 #include<sstream>
00004 
00005 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
00006 
00007 using namespace std;
00008 
00009 string JetDefinition::description() const {
00010   ostringstream name;
00011   if (jet_finder() == plugin_algorithm) {
00012     return plugin()->description();
00013   } else if (jet_finder() == kt_algorithm) {
00014     name << "Longitudinally invariant kt algorithm with R = " << R();
00015     name << " and " << recombiner()->description();
00016   } else if (jet_finder() == cambridge_algorithm) {
00017     name << "Longitudinally invariant Cambridge/Aachen algorithm with R = " 
00018          << R() ;
00019     name << " and " << recombiner()->description();
00020   } else {
00021     throw Error("Unrecognized jet_finder");
00022   }
00023   return name.str();
00024 }
00025 
00026 
00027 void JetDefinition::set_recombination_scheme(
00028                                RecombinationScheme recomb_scheme) {
00029   _default_recombiner = JetDefinition::DefaultRecombiner(recomb_scheme);
00030   _recombiner = 0;
00031 }
00032 
00033 
00034 string JetDefinition::DefaultRecombiner::description() const {
00035   switch(_recomb_scheme) {
00036   case E_scheme:
00037     return "E scheme recombination";
00038   case pt_scheme:
00039     return "pt scheme recombination";
00040   case pt2_scheme:
00041     return "pt2 scheme recombination";
00042   case Et_scheme:
00043     return "Et scheme recombination";
00044   case Et2_scheme:
00045     return "Et2 scheme recombination";
00046   case BIpt_scheme:
00047     return "boost-invariant pt scheme recombination";
00048   case BIpt2_scheme:
00049     return "boost-invariant pt2 scheme recombination";
00050   default:
00051     ostringstream err;
00052     err << "DefaultRecombiner: unrecognized recombination scheme " 
00053         << _recomb_scheme;
00054     throw Error(err.str());
00055   }
00056 }
00057 
00058 
00059 void JetDefinition::DefaultRecombiner::recombine(
00060            const PseudoJet & pa, const PseudoJet & pb,
00061            PseudoJet & pab) const {
00062   
00063   double weighta, weightb;
00064 
00065   switch(_recomb_scheme) {
00066   case E_scheme:
00067     pab = pa + pb; 
00068     pab.set_user_index(0);
00069     return;
00070   // all remaining schemes are massless recombinations and locally
00071   // we just set weights, while the hard work is done below...
00072   case pt_scheme:
00073   case Et_scheme:
00074   case BIpt_scheme:
00075     weighta = pa.perp(); 
00076     weightb = pb.perp();
00077     break;
00078   case pt2_scheme:
00079   case Et2_scheme:
00080   case BIpt2_scheme:
00081     weighta = pa.perp2(); 
00082     weightb = pb.perp2();
00083     break;
00084   default:
00085     ostringstream err;
00086     err << "DefaultRecombiner: unrecognized recombination scheme " 
00087         << _recomb_scheme;
00088     throw Error(err.str());
00089   }
00090 
00091   double perp_ab = pa.perp() + pb.perp();
00092   if (perp_ab != 0.0) { // weights also non-zero...
00093     double y_ab    = (weighta * pa.rap() + weightb * pb.rap())/(weighta+weightb);
00094     
00095     // take care with periodicity in phi...
00096     double phi_a = pa.phi(), phi_b = pb.phi();
00097     if (phi_a - phi_b > pi)  phi_b += twopi;
00098     if (phi_a - phi_b < -pi) phi_b -= twopi;
00099     double phi_ab = (weighta * phi_a + weightb * phi_b)/(weighta+weightb);
00100     
00101     pab = PseudoJet(perp_ab*cos(phi_ab),
00102                     perp_ab*sin(phi_ab),
00103                     perp_ab*sinh(y_ab),
00104                     perp_ab*cosh(y_ab));
00105   } else { // weights are zero
00106     pab = PseudoJet(0.0,0.0,0.0,0.0);
00107   }
00108   pab.set_user_index(0);
00109 }
00110 
00111 
00112 void JetDefinition::DefaultRecombiner::preprocess(PseudoJet & p) const {
00113   switch(_recomb_scheme) {
00114   case E_scheme:
00115   case BIpt_scheme:
00116   case BIpt2_scheme:
00117     break;
00118   case pt_scheme:
00119   case pt2_scheme:
00120     {
00121       // these schemes (as in the ktjet implementation) need massless
00122       // initial 4-vectors with essentially E=|p|.
00123       double newE = sqrt(p.perp2()+p.pz()*p.pz());
00124       int    user_index = p.user_index();
00125       p = PseudoJet(p.px(), p.py(), p.pz(), newE);
00126       p.set_user_index(user_index);
00127     }
00128     break;
00129   case Et_scheme:
00130   case Et2_scheme:
00131     {
00132       // these schemes (as in the ktjet implementation) need massless
00133       // initial 4-vectors with essentially E=|p|.
00134       double rescale = p.E()/sqrt(p.perp2()+p.pz()*p.pz());
00135       int    user_index = p.user_index();
00136       p = PseudoJet(rescale*p.px(), rescale*p.py(), rescale*p.pz(), p.E());
00137       p.set_user_index(user_index);
00138     }
00139     break;
00140   default:
00141     ostringstream err;
00142     err << "DefaultRecombiner: unrecognized recombination scheme " 
00143         << _recomb_scheme;
00144     throw Error(err.str());
00145   }
00146 }
00147 
00148 FASTJET_END_NAMESPACE

Generated on Mon Apr 2 20:57:48 2007 for fastjet by  doxygen 1.4.2