JetDefinition::DefaultRecombiner

#include <fjcore.hh>

Inheritance diagram for JetDefinition::DefaultRecombiner:

Collaboration diagram for JetDefinition::DefaultRecombiner:

Public Member Functions
	DefaultRecombiner (RecombinationScheme recomb_scheme=E_scheme)
virtual std::string	description () const FJCORE_OVERRIDE
virtual void	recombine (const PseudoJet &pa, const PseudoJet &pb, PseudoJet &pab) const FJCORE_OVERRIDE
virtual void	preprocess (PseudoJet &p) const FJCORE_OVERRIDE
RecombinationScheme	scheme () const
Public Member Functions inherited from JetDefinition::Recombiner
virtual	~Recombiner ()
void	plus_equal (PseudoJet &pa, const PseudoJet &pb) const

Private Attributes
RecombinationScheme	_recomb_scheme

Constructor & Destructor Documentation

DefaultRecombiner()

DefaultRecombiner ( RecombinationScheme  recomb_scheme = E_scheme )

inline

                                                                    :
      _recomb_scheme(recomb_scheme) {}

Member Function Documentation

description()

string description ( ) const

virtual

Implements JetDefinition::Recombiner.

                                                         {
  switch(_recomb_scheme) {
  case E_scheme:
    return "E scheme recombination";
  case pt_scheme:
    return "pt scheme recombination";
  case pt2_scheme:
    return "pt2 scheme recombination";
  case Et_scheme:
    return "Et scheme recombination";
  case Et2_scheme:
    return "Et2 scheme recombination";
  case BIpt_scheme:
    return "boost-invariant pt scheme recombination";
  case BIpt2_scheme:
    return "boost-invariant pt2 scheme recombination";
  case WTA_pt_scheme:
    return "pt-ordered Winner-Takes-All recombination";
  case WTA_modp_scheme:
    return "|3-momentum|-ordered Winner-Takes-All recombination";
  default:
    ostringstream err;
    err << "DefaultRecombiner: unrecognized recombination scheme "
        << _recomb_scheme;
    throw Error(err.str());
  }
}

preprocess()

void preprocess ( PseudoJet &  p ) const

virtual

Reimplemented from JetDefinition::Recombiner.

                                                                   {
  switch(_recomb_scheme) {
  case E_scheme:
  case BIpt_scheme:
  case BIpt2_scheme:
  case WTA_pt_scheme:
  case WTA_modp_scheme:
    break;
  case pt_scheme:
  case pt2_scheme:
    {
      double newE = sqrt(p.perp2()+p.pz()*p.pz());
      p.reset_momentum(p.px(), p.py(), p.pz(), newE);
    }
    break;
  case Et_scheme:
  case Et2_scheme:
    {
      double rescale = p.E()/sqrt(p.perp2()+p.pz()*p.pz());
      p.reset_momentum(rescale*p.px(), rescale*p.py(), rescale*p.pz(), p.E());
    }
    break;
  default:
    ostringstream err;
    err << "DefaultRecombiner: unrecognized recombination scheme "
        << _recomb_scheme;
    throw Error(err.str());
  }
}

recombine()

void recombine ( const PseudoJet &  pa, const PseudoJet &  pb, PseudoJet &  pab  ) const

virtual

Implements JetDefinition::Recombiner.

                                  {
  double weighta, weightb;
  switch(_recomb_scheme) {
  case E_scheme:
    pab.reset(pa.px()+pb.px(),
              pa.py()+pb.py(),
              pa.pz()+pb.pz(),
              pa.E ()+pb.E ());
    return;
  case pt_scheme:
  case Et_scheme:
  case BIpt_scheme:
    weighta = pa.perp();
    weightb = pb.perp();
    break;
  case pt2_scheme:
  case Et2_scheme:
  case BIpt2_scheme:
    weighta = pa.perp2();
    weightb = pb.perp2();
    break;
  case WTA_pt_scheme:{
    const PseudoJet & phard = (pa.pt2() >= pb.pt2()) ? pa : pb;
    pab.reset_PtYPhiM(pa.pt()+pb.pt(),
                      phard.rap(), phard.phi(), phard.m());
    return;}
  case WTA_modp_scheme:{
    bool a_hardest = (pa.modp2() >= pb.modp2());
    const PseudoJet & phard = a_hardest ? pa : pb;
    const PseudoJet & psoft = a_hardest ? pb : pa;
    double modp_hard = phard.modp();
    double modp_ab = modp_hard + psoft.modp();
    if (phard.modp2()==0.0){
      pab.reset(0.0, 0.0, 0.0, phard.m());
    } else {
      double scale = modp_ab/modp_hard;
      pab.reset(phard.px()*scale, phard.py()*scale, phard.pz()*scale,
                sqrt(modp_ab*modp_ab + phard.m2()));
    }
    return;}
  default:
    ostringstream err;
    err << "DefaultRecombiner: unrecognized recombination scheme "
        << _recomb_scheme;
    throw Error(err.str());
  }
  double perp_ab = pa.perp() + pb.perp();
  if (perp_ab != 0.0) { // weights also non-zero...
    double y_ab    = (weighta * pa.rap() + weightb * pb.rap())/(weighta+weightb);
    double phi_a = pa.phi(), phi_b = pb.phi();
    if (phi_a - phi_b > pi)  phi_b += twopi;
    if (phi_a - phi_b < -pi) phi_b -= twopi;
    double phi_ab = (weighta * phi_a + weightb * phi_b)/(weighta+weightb);
    pab.reset_PtYPhiM(perp_ab,y_ab,phi_ab);
  } else { // weights are zero
    pab.reset(0.0, 0.0, 0.0, 0.0);
  }
}

scheme()

RecombinationScheme scheme ( ) const

inline

{return _recomb_scheme;}

Member Data Documentation

_recomb_scheme

RecombinationScheme _recomb_scheme

private

---

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

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/interface/fjcore.hh
• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/src/fjcore.cc