#include <fjcore.hh>

Collaboration diagram for PseudoJet:

Classes
class	InexistentUserInfo

class	UserInfoBase

Public Types
enum	{ X =0, Y =1, Z =2, T =3, NUM_COORDINATES =4, SIZE =NUM_COORDINATES }

Public Member Functions
	PseudoJet ()

	PseudoJet (const double px, const double py, const double pz, const double E)

template<class L >
	PseudoJet (const L &some_four_vector)

	PseudoJet (bool)

virtual	~PseudoJet ()

double	E () const

double	e () const

double	px () const

double	py () const

double	pz () const

double	phi () const

double	phi_std () const

double	phi_02pi () const

double	rap () const

double	rapidity () const

double	pseudorapidity () const

double	eta () const

double	pt2 () const

double	pt () const

double	perp2 () const

double	perp () const

double	CorrPt () const

double	kt2 () const

double	m2 () const

double	m () const

double	mperp2 () const

double	mperp () const

double	mt2 () const

double	mt () const

double	modp2 () const

double	modp () const

double	Et () const

double	Et2 () const

double	cos_theta () const

double	theta () const

double	operator() (int i) const

double	operator[] (int i) const

double	kt_distance (const PseudoJet &other) const

double	plain_distance (const PseudoJet &other) const

double	squared_distance (const PseudoJet &other) const

double	delta_R (const PseudoJet &other) const

double	delta_phi_to (const PseudoJet &other) const

double	beam_distance () const

std::valarray< double >	four_mom () const

PseudoJet &	boost (const PseudoJet &prest)

PseudoJet &	unboost (const PseudoJet &prest)

PseudoJet &	operator*= (double)

PseudoJet &	operator/= (double)

PseudoJet &	operator+= (const PseudoJet &)

PseudoJet &	operator-= (const PseudoJet &)

void	reset (double px, double py, double pz, double E)

void	reset (const PseudoJet &psjet)

template<class L >
void	reset (const L &some_four_vector)

void	reset_PtYPhiM (double pt_in, double y_in, double phi_in, double m_in=0.0)

void	reset_momentum (double px, double py, double pz, double E)

void	reset_momentum (const PseudoJet &pj)

void	reset_momentum_PtYPhiM (double pt, double y, double phi, double m=0.0)

template<class L >
void	reset_momentum (const L &some_four_vector)

void	set_cached_rap_phi (double rap, double phi)

int	user_index () const

void	set_user_index (const int index)

void	set_user_info (UserInfoBase *user_info_in)

template<class L >
const L &	user_info () const

bool	has_user_info () const

template<class L >
bool	has_user_info () const

const UserInfoBase *	user_info_ptr () const

const SharedPtr< UserInfoBase > &	user_info_shared_ptr () const

SharedPtr< UserInfoBase > &	user_info_shared_ptr ()

std::string	description () const

bool	has_associated_cluster_sequence () const

bool	has_associated_cs () const

bool	has_valid_cluster_sequence () const

bool	has_valid_cs () const

const ClusterSequence *	associated_cluster_sequence () const

const ClusterSequence *	associated_cs () const

const ClusterSequence *	validated_cluster_sequence () const

const ClusterSequence *	validated_cs () const

void	set_structure_shared_ptr (const SharedPtr< PseudoJetStructureBase > &structure)

bool	has_structure () const

const PseudoJetStructureBase *	structure_ptr () const

PseudoJetStructureBase *	structure_non_const_ptr ()

const PseudoJetStructureBase *	validated_structure_ptr () const

const SharedPtr< PseudoJetStructureBase > &	structure_shared_ptr () const

template<typename StructureType >
const StructureType &	structure () const

template<typename TransformerType >
bool	has_structure_of () const

template<typename TransformerType >
const TransformerType::StructureType &	structure_of () const

virtual bool	has_partner (PseudoJet &partner) const

virtual bool	has_child (PseudoJet &child) const

virtual bool	has_parents (PseudoJet &parent1, PseudoJet &parent2) const

virtual bool	contains (const PseudoJet &constituent) const

virtual bool	is_inside (const PseudoJet &jet) const

virtual bool	has_constituents () const

virtual std::vector< PseudoJet >	constituents () const

virtual bool	has_exclusive_subjets () const

std::vector< PseudoJet >	exclusive_subjets (const double dcut) const

int	n_exclusive_subjets (const double dcut) const

std::vector< PseudoJet >	exclusive_subjets (int nsub) const

std::vector< PseudoJet >	exclusive_subjets_up_to (int nsub) const

double	exclusive_subdmerge (int nsub) const

double	exclusive_subdmerge_max (int nsub) const

virtual bool	has_pieces () const

virtual std::vector< PseudoJet >	pieces () const

int	cluster_hist_index () const

void	set_cluster_hist_index (const int index)

int	cluster_sequence_history_index () const

void	set_cluster_sequence_history_index (const int index)

Protected Attributes
SharedPtr< PseudoJetStructureBase >	_structure

SharedPtr< UserInfoBase >	_user_info

Private Member Functions
void	_finish_init ()

void	_reset_indices ()

void	_ensure_valid_rap_phi () const

void	_set_rap_phi () const

Private Attributes
double	_px

double	_py

double	_pz

double	_E

double	_phi

double	_rap

double	_kt2

int	_cluster_hist_index

int	_user_index

Friends
PseudoJet	operator* (double, const PseudoJet &)

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
X
Y
Z
T
NUM_COORDINATES
SIZE

596 { X=0, Y=1, Z=2, T=3, NUM_COORDINATES=4, SIZE=NUM_COORDINATES };

Constructor & Destructor Documentation

◆ PseudoJet() [1/4]

PseudoJet ( )

inline

537 : _px(0), _py(0), _pz(0), _E(0) {_finish_init(); _reset_indices();}

◆ PseudoJet() [2/4]

PseudoJet	(	const double	px,
		const double	py,
		const double	pz,
		const double	E
	)

                                                                                                   {
   _E  = E_in ;
   _px = px_in;
   _py = py_in;
   _pz = pz_in;
   this->_finish_init();
   _reset_indices();
 }

◆ PseudoJet() [3/4]

PseudoJet ( const L & some_four_vector )

inline

                                                                           {
   reset(some_four_vector);
 }

◆ PseudoJet() [4/4]

PseudoJet ( bool )

inline

542 {}

◆ ~PseudoJet()

virtual ~PseudoJet ( )

inlinevirtual

543 {};

Member Function Documentation

◆ _ensure_valid_rap_phi()

void _ensure_valid_rap_phi ( ) const

inlineprivate

                                             {
     if (_phi == pseudojet_invalid_phi) _set_rap_phi();
   }

◆ _finish_init()

void _finish_init ( )

private

                               {
   _kt2 = this->px()*this->px() + this->py()*this->py();
   _phi = pseudojet_invalid_phi;
   _rap = pseudojet_invalid_rap;
 }

◆ _reset_indices()

void _reset_indices ( )

inlineprivate

                                       {
   set_cluster_hist_index(-1);
   set_user_index(-1);
   _structure.reset();
   _user_info.reset();
 }

◆ _set_rap_phi()

void _set_rap_phi ( ) const

private

                                    {
   if (_kt2 == 0.0) {
     _phi = 0.0; }
   else {
     _phi = atan2(this->py(),this->px());
   }
   if (_phi < 0.0) {_phi += twopi;}
   if (_phi >= twopi) {_phi -= twopi;} // can happen if phi=-|eps<1e-15|?
   if (this->E() == abs(this->pz()) && _kt2 == 0) {
     double MaxRapHere = MaxRap + abs(this->pz());
     if (this->pz() >= 0.0) {_rap = MaxRapHere;} else {_rap = -MaxRapHere;}
   } else {
     double effective_m2 = max(0.0,m2()); // force non tachyonic mass
     double E_plus_pz    = _E + abs(_pz); // the safer of p+, p-
     _rap = 0.5*log((_kt2 + effective_m2)/(E_plus_pz*E_plus_pz));
     if (_pz > 0) {_rap = - _rap;}
   }
 }

◆ associated_cluster_sequence()

const ClusterSequence * associated_cluster_sequence ( ) const

                                                                    {
   if (! has_associated_cluster_sequence()) return NULL;
   return _structure->associated_cluster_sequence();
 }

◆ associated_cs()

const ClusterSequence* associated_cs ( ) const

inline

671 {return associated_cluster_sequence();}

◆ beam_distance()

double beam_distance ( ) const

inline

594 {return _kt2;}

◆ boost()

PseudoJet & boost ( const PseudoJet & prest )

                                                     {
   if (prest.px() == 0.0 && prest.py() == 0.0 && prest.pz() == 0.0)
     return *this;
   double m_local = prest.m();
   assert(m_local != 0);
   double pf4  = (  px()*prest.px() + py()*prest.py()
                  + pz()*prest.pz() + E()*prest.E() )/m_local;
   double fn   = (pf4 + E()) / (prest.E() + m_local);
   _px +=  fn*prest.px();
   _py +=  fn*prest.py();
   _pz +=  fn*prest.pz();
   _E = pf4;
   _finish_init(); // we need to recalculate phi,rap,kt2
   return *this;
 }

◆ cluster_hist_index()

int cluster_hist_index ( ) const

inline

704 {return _cluster_hist_index;}

◆ cluster_sequence_history_index()

int cluster_sequence_history_index ( ) const

inline

706 {

707 return cluster_hist_index();}

◆ constituents()

vector< PseudoJet > constituents ( ) const

virtual

                                                {
   return validated_structure_ptr()->constituents(*this);
 }

◆ contains()

bool contains ( const PseudoJet & constituent ) const

virtual

                                                           {
   return validated_structure_ptr()->object_in_jet(constituent, *this);
 }

◆ CorrPt()

double CorrPt ( ) const

inline

568 {return sqrt(_kt2);}

◆ cos_theta()

double cos_theta ( ) const

inline

                                   {
     return std::min(1.0, std::max(-1.0, _pz/sqrt(modp2())));
   }

◆ delta_phi_to()

double delta_phi_to ( const PseudoJet & other ) const

                                                             {
   double dphi = other.phi() - phi();
   if (dphi >  pi) dphi -= twopi;
   if (dphi < -pi) dphi += twopi;
   return dphi;
 }

◆ delta_R()

double delta_R ( const PseudoJet & other ) const

inline

                                                        {
     return sqrt(squared_distance(other));
   }

◆ description()

string description ( ) const

                                    {
   if (!_structure)
     return "standard PseudoJet (with no associated clustering information)";
   return _structure->description();
 }

◆ E()

double E ( ) const

inline

544 {return _E;}

◆ e()

double e ( ) const

inline

545 {return _E;} // like CLHEP

◆ Et()

double Et ( ) const

inline

578 {return (_kt2==0) ? 0.0 : _E/sqrt(1.0+_pz*_pz/_kt2);}

◆ Et2()

double Et2 ( ) const

inline

579 {return (_kt2==0) ? 0.0 : _E*_E/(1.0+_pz*_pz/_kt2);}

◆ eta()

double eta ( ) const

inline

563 {return pseudorapidity();}

◆ exclusive_subdmerge()

double exclusive_subdmerge ( int nsub ) const

                                                     {
   return validated_structure_ptr()->exclusive_subdmerge(*this, nsub);
 }

◆ exclusive_subdmerge_max()

double exclusive_subdmerge_max ( int nsub ) const

                                                         {
   return validated_structure_ptr()->exclusive_subdmerge_max(*this, nsub);
 }

◆ exclusive_subjets() [1/2]

std::vector< PseudoJet > exclusive_subjets ( const double dcut ) const

                                                                           {
   return validated_structure_ptr()->exclusive_subjets(*this, dcut);
 }

◆ exclusive_subjets() [2/2]

std::vector< PseudoJet > exclusive_subjets ( int nsub ) const

                                                                  {
   vector<PseudoJet> subjets = exclusive_subjets_up_to(nsub);
   if (int(subjets.size()) < nsub) {
     ostringstream err;
     err << "Requested " << nsub << " exclusive subjets, but there were only "
     << subjets.size() << " particles in the jet";
     throw Error(err.str());
   }
   return subjets;
 }

◆ exclusive_subjets_up_to()

std::vector< PseudoJet > exclusive_subjets_up_to ( int nsub ) const

                                                                        {
   return validated_structure_ptr()->exclusive_subjets_up_to(*this, nsub);
 }

◆ four_mom()

valarray< double > four_mom ( ) const

                                            {
   valarray<double> mom(4);
   mom[0] = _px;
   mom[1] = _py;
   mom[2] = _pz;
   mom[3] = _E ;
   return mom;
 }

◆ has_associated_cluster_sequence()

bool has_associated_cluster_sequence ( ) const

                                                      {
   return (_structure) && (_structure->has_associated_cluster_sequence());
 }

◆ has_associated_cs()

bool has_associated_cs ( ) const

inline

667 {return has_associated_cluster_sequence();}

◆ has_child()

bool has_child ( PseudoJet & child ) const

virtual

                                                {
   return validated_structure_ptr()->has_child(*this, child);
 }

◆ has_constituents()

bool has_constituents ( ) const

virtual

                                       {
   return (_structure) && (_structure->has_constituents());
 }

◆ has_exclusive_subjets()

bool has_exclusive_subjets ( ) const

virtual

                                            {
   return (_structure) && (_structure->has_exclusive_subjets());
 }

◆ has_parents()

bool has_parents	(	PseudoJet &	parent1,
		PseudoJet &	parent2
	)		const

virtual

                                                                        {
   return validated_structure_ptr()->has_parents(*this, parent1, parent2);
 }

◆ has_partner()

bool has_partner ( PseudoJet & partner ) const

virtual

                                                    {
   return validated_structure_ptr()->has_partner(*this, partner);
 }

◆ has_pieces()

bool has_pieces ( ) const

virtual

                                 {
   return ((_structure) && (_structure->has_pieces(*this)));
 }

◆ has_structure()

bool has_structure ( ) const

                                    {
   return bool(_structure);
 }

◆ has_structure_of()

bool has_structure_of

                                       {
   if (!_structure) return false;
   return dynamic_cast<const typename TransformerType::StructureType *>(_structure.get()) != 0;
 }

◆ has_user_info() [1/2]

bool has_user_info ( ) const

inline

                             {
     return _user_info.get();
   }

◆ has_user_info() [2/2]

bool has_user_info ( ) const

inline

                             {
     return _user_info.get() && dynamic_cast<const L *>(_user_info.get());
   }

◆ has_valid_cluster_sequence()

bool has_valid_cluster_sequence ( ) const

                                                 {
   return (_structure) && (_structure->has_valid_cluster_sequence());
 }

◆ has_valid_cs()

bool has_valid_cs ( ) const

inline

669 {return has_valid_cluster_sequence();}

◆ is_inside()

bool is_inside ( const PseudoJet & jet ) const

virtual

                                                    {
   return validated_structure_ptr()->object_in_jet(*this, jet);
 }

◆ kt2()

double kt2 ( ) const

inline

569 {return _kt2;} // for bkwds compatibility

◆ kt_distance()

double kt_distance ( const PseudoJet & other ) const

                                                            {
   double distance = min(_kt2, other._kt2);
   double dphi = abs(phi() - other.phi());
   if (dphi > pi) {dphi = twopi - dphi;}
   double drap = rap() - other.rap();
   distance = distance * (dphi*dphi + drap*drap);
   return distance;
 }

◆ m()

double m ( ) const

inline

                                  {
   double mm = m2();
   return mm < 0.0 ? -std::sqrt(-mm) : std::sqrt(mm);
 }

◆ m2()

double m2 ( ) const

inline

570 {return (_E+_pz)*(_E-_pz)-_kt2;}

◆ modp()

double modp ( ) const

inline

577 {return sqrt(_kt2+_pz*_pz);}

◆ modp2()

double modp2 ( ) const

inline

576 {return _kt2+_pz*_pz;}

◆ mperp()

double mperp ( ) const

inline

573 {return sqrt(std::abs(mperp2()));}

◆ mperp2()

double mperp2 ( ) const

inline

572 {return (_E+_pz)*(_E-_pz);}

◆ mt()

double mt ( ) const

inline

575 {return sqrt(std::abs(mperp2()));}

◆ mt2()

double mt2 ( ) const

inline

574 {return (_E+_pz)*(_E-_pz);}

◆ n_exclusive_subjets()

int n_exclusive_subjets ( const double dcut ) const

                                                           {
   return validated_structure_ptr()->n_exclusive_subjets(*this, dcut);
 }

◆ operator()()

double operator() ( int i ) const

                                           {
   switch(i) {
   case X:
     return px();
   case Y:
     return py();
   case Z:
     return pz();
   case T:
     return e();
   default:
     ostringstream err;
     err << "PseudoJet subscripting: bad index (" << i << ")";
     throw Error(err.str());
   }
   return 0.;
 }

◆ operator*=()

PseudoJet & operator*= ( double coeff )

                                               {
   _ensure_valid_rap_phi();
   _px *= coeff;
   _py *= coeff;
   _pz *= coeff;
   _E  *= coeff;
   _kt2*= coeff*coeff;
   return *this;
 }

◆ operator+=()

PseudoJet & operator+= ( const PseudoJet & other_jet )

                                                              {
   _px += other_jet._px;
   _py += other_jet._py;
   _pz += other_jet._pz;
   _E  += other_jet._E ;
   _finish_init(); // we need to recalculate phi,rap,kt2
   return *this;
 }

◆ operator-=()

PseudoJet & operator-= ( const PseudoJet & other_jet )

                                                              {
   _px -= other_jet._px;
   _py -= other_jet._py;
   _pz -= other_jet._pz;
   _E  -= other_jet._E ;
   _finish_init(); // we need to recalculate phi,rap,kt2
   return *this;
 }

◆ operator/=()

PseudoJet & operator/= ( double coeff )

                                               {
   (*this) *= 1.0/coeff;
   return *this;
 }

◆ operator[]()

double operator[] ( int i ) const

inline

585 { return (*this)(i); }; // this too

◆ perp()

double perp ( ) const

inline

567 {return sqrt(_kt2);} // like CLHEP

◆ perp2()

double perp2 ( ) const

inline

566 {return _kt2;} // like CLHEP

◆ phi()

double phi ( ) const

inline

549 {return phi_02pi();}

◆ phi_02pi()

double phi_02pi ( ) const

inline

                                  {
     _ensure_valid_rap_phi();
     return _phi;
   }

◆ phi_std()

double phi_std ( ) const

inline

                                  {
     _ensure_valid_rap_phi();
     return _phi > pi ? _phi-twopi : _phi;}

◆ pieces()

std::vector< PseudoJet > pieces ( ) const

virtual

                                             {
   return validated_structure_ptr()->pieces(*this);
 }

◆ plain_distance()

double plain_distance ( const PseudoJet & other ) const

                                                               {
   double dphi = abs(phi() - other.phi());
   if (dphi > pi) {dphi = twopi - dphi;}
   double drap = rap() - other.rap();
   return (dphi*dphi + drap*drap);
 }

◆ pseudorapidity()

double pseudorapidity ( ) const

                                        {
   if (px() == 0.0 && py() ==0.0) return MaxRap;
   if (pz() == 0.0) return 0.0;
   double theta = atan(perp()/pz());
   if (theta < 0) theta += pi;
   return -log(tan(theta/2));
 }

◆ pt()

double pt ( ) const

inline

565 {return sqrt(_kt2);}

◆ pt2()

double pt2 ( ) const

inline

564 {return _kt2;}

◆ px()

double px ( ) const

inline

546 {return _px;}

◆ py()

double py ( ) const

inline

547 {return _py;}

◆ pz()

double pz ( ) const

inline

548 {return _pz;}

◆ rap()

double rap ( ) const

inline

                             {
     _ensure_valid_rap_phi();
     return _rap;
   }

◆ rapidity()

double rapidity ( ) const

inline

561 {return rap();} // like CLHEP

◆ reset() [1/3]

void reset ( const L & some_four_vector )

inline

                                                                    {
     const PseudoJet * pj = fjcore::cast_if_derived<const PseudoJet>(&some_four_vector);
     if (pj){
       (*this) = *pj;
     } else {
       reset(some_four_vector[0], some_four_vector[1],
         some_four_vector[2], some_four_vector[3]);
     }
   }

◆ reset() [2/3]

void reset ( const PseudoJet & psjet )

inline

                                              {
     (*this) = psjet;
   }

◆ reset() [3/3]

void reset	(	double	px,
		double	py,
		double	pz,
		double	E
	)

inline

                                                                                   {
   _px = px_in;
   _py = py_in;
   _pz = pz_in;
   _E  = E_in;
   _finish_init();
   _reset_indices();
 }

◆ reset_momentum() [1/3]

void reset_momentum ( const L & some_four_vector )

inline

                                                                             {
     reset_momentum(some_four_vector[0], some_four_vector[1],
            some_four_vector[2], some_four_vector[3]);
   }

◆ reset_momentum() [2/3]

void reset_momentum ( const PseudoJet & pj )

inline

                                                           {
   _px  = pj._px ;
   _py  = pj._py ;
   _pz  = pj._pz ;
   _E   = pj._E  ;
   _phi = pj._phi;
   _rap = pj._rap;
   _kt2 = pj._kt2;
 }

◆ reset_momentum() [3/3]

void reset_momentum	(	double	px,
		double	py,
		double	pz,
		double	E
	)

inline

                                                                                            {
   _px = px_in;
   _py = py_in;
   _pz = pz_in;
   _E  = E_in;
   _finish_init();
 }

◆ reset_momentum_PtYPhiM()

void reset_momentum_PtYPhiM	(	double	pt,
		double	y,
		double	phi,
		double	m = `0.0`
	)

                                                                                             {
   assert(phi_in < 2*twopi && phi_in > -twopi);
   double ptm = (m_in == 0) ? pt_in : sqrt(pt_in*pt_in+m_in*m_in);
   double exprap = exp(y_in);
   double pminus = ptm/exprap;
   double pplus  = ptm*exprap;
   double px_local = pt_in*cos(phi_in);
   double py_local = pt_in*sin(phi_in);
   reset_momentum(px_local,py_local,0.5*(pplus-pminus),0.5*(pplus+pminus));
   set_cached_rap_phi(y_in,phi_in);
 }

◆ reset_PtYPhiM()

void reset_PtYPhiM	(	double	pt_in,
		double	y_in,
		double	phi_in,
		double	m_in = `0.0`
	)

inline

                                                                                        {
     reset_momentum_PtYPhiM(pt_in, y_in, phi_in, m_in);
     _reset_indices();
   }

◆ set_cached_rap_phi()

void set_cached_rap_phi	(	double	rap,
		double	phi
	)

                                                                {
   _rap = rap_in; _phi = phi_in;
   if (_phi >= twopi) _phi -= twopi;
   if (_phi < 0)      _phi += twopi;
 }

◆ set_cluster_hist_index()

void set_cluster_hist_index ( const int index )

inline

705 {_cluster_hist_index = index;}

◆ set_cluster_sequence_history_index()

void set_cluster_sequence_history_index ( const int index )

inline

708 {

709 set_cluster_hist_index(index);}

◆ set_structure_shared_ptr()

void set_structure_shared_ptr ( const SharedPtr< PseudoJetStructureBase > & structure )

                                                                                              {
   _structure = structure_in;
 }

◆ set_user_index()

void set_user_index ( const int index )

inline

631 {_user_index = index;}

◆ set_user_info()

void set_user_info ( UserInfoBase * user_info_in )

inline

                                                   {
     _user_info.reset(user_info_in);
   }

◆ squared_distance()

double squared_distance ( const PseudoJet & other ) const

inline

588 {

589 return plain_distance(other);}

◆ structure()

const StructureType & structure

                                                 {
   return dynamic_cast<const StructureType &>(* validated_structure_ptr());
 }

◆ structure_non_const_ptr()

PseudoJetStructureBase * structure_non_const_ptr ( )

                                                           {
   return _structure.get();
 }

◆ structure_of()

const TransformerType::StructureType & structure_of

                                                                            {
   if (!_structure)
     throw Error("Trying to access the structure of a PseudoJet without an associated structure");
   return dynamic_cast<const typename TransformerType::StructureType &>(*_structure);
 }

◆ structure_ptr()

const PseudoJetStructureBase * structure_ptr ( ) const

                                                              {
   return _structure.get();
 }

◆ structure_shared_ptr()

const SharedPtr< PseudoJetStructureBase > & structure_shared_ptr ( ) const

                                                                                 {
   return _structure;
 }

◆ theta()

double theta ( ) const

inline

583 { return acos(cos_theta()); }

◆ unboost()

PseudoJet & unboost ( const PseudoJet & prest )

                                                       {
   if (prest.px() == 0.0 && prest.py() == 0.0 && prest.pz() == 0.0)
     return *this;
   double m_local = prest.m();
   assert(m_local != 0);
   double pf4  = ( -px()*prest.px() - py()*prest.py()
                  - pz()*prest.pz() + E()*prest.E() )/m_local;
   double fn   = (pf4 + E()) / (prest.E() + m_local);
   _px -=  fn*prest.px();
   _py -=  fn*prest.py();
   _pz -=  fn*prest.pz();
   _E = pf4;
   _finish_init(); // we need to recalculate phi,rap,kt2
   return *this;
 }

◆ user_index()

int user_index ( ) const

inline

630 {return _user_index;}

◆ user_info()

const L& user_info ( ) const

inline

                              {
     if (_user_info.get() == 0) throw InexistentUserInfo();
     return dynamic_cast<const L &>(* _user_info.get());
   }

◆ user_info_ptr()

const UserInfoBase* user_info_ptr ( ) const

inline

                                             {
     return _user_info.get();
   }

◆ user_info_shared_ptr() [1/2]

SharedPtr<UserInfoBase>& user_info_shared_ptr ( )

inline

                                                   {
     return _user_info;
   }

◆ user_info_shared_ptr() [2/2]

const SharedPtr<UserInfoBase>& user_info_shared_ptr ( ) const

inline

                                                               {
     return _user_info;
   }

◆ validated_cluster_sequence()

const ClusterSequence* validated_cluster_sequence ( ) const

inline

                                                                     {
     return validated_cs();
   }

◆ validated_cs()

const ClusterSequence * validated_cs ( ) const

                                                       {
   return validated_structure_ptr()->validated_cs();
 }

◆ validated_structure_ptr()

const PseudoJetStructureBase * validated_structure_ptr ( ) const

                                                                        {
   if (!_structure)
     throw Error("Trying to access the structure of a PseudoJet which has no associated structure");
   return _structure.get();
 }

Friends And Related Function Documentation

◆ operator*

PseudoJet operator*	(	double	coeff,
		const PseudoJet &	jet
	)

friend

                                                           {
   jet._ensure_valid_rap_phi();
   PseudoJet coeff_times_jet(jet);
   coeff_times_jet *= coeff;
   return coeff_times_jet;
 }

Member Data Documentation

◆ _cluster_hist_index

int _cluster_hist_index

private

◆ _E

double _E

private

◆ _kt2

double _kt2

private

◆ _phi

double _phi

mutableprivate

◆ _px

double _px

private

◆ _py

double _py

private

◆ _pz

double _pz

private

◆ _rap

double _rap

private

◆ _structure

SharedPtr<PseudoJetStructureBase> _structure

protected

◆ _user_index

int _user_index

private

◆ _user_info

SharedPtr<UserInfoBase> _user_info

protected

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

Classes

Public Types

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ PseudoJet() [1/4]

◆ PseudoJet() [2/4]

◆ PseudoJet() [3/4]

◆ PseudoJet() [4/4]

◆ ~PseudoJet()

Member Function Documentation

◆ _ensure_valid_rap_phi()

◆ _finish_init()

◆ _reset_indices()

◆ _set_rap_phi()

◆ associated_cluster_sequence()

◆ associated_cs()

◆ beam_distance()

◆ boost()

◆ cluster_hist_index()

◆ cluster_sequence_history_index()

◆ constituents()

◆ contains()

◆ CorrPt()

◆ cos_theta()

◆ delta_phi_to()

◆ delta_R()

◆ description()

◆ E()

◆ e()

◆ Et()

◆ Et2()

◆ eta()

◆ exclusive_subdmerge()

◆ exclusive_subdmerge_max()

◆ exclusive_subjets() [1/2]

◆ exclusive_subjets() [2/2]

◆ exclusive_subjets_up_to()

◆ four_mom()

◆ has_associated_cluster_sequence()

◆ has_associated_cs()

◆ has_child()

◆ has_constituents()

◆ has_exclusive_subjets()

◆ has_parents()

◆ has_partner()

◆ has_pieces()

◆ has_structure()

◆ has_structure_of()

◆ has_user_info() [1/2]

◆ has_user_info() [2/2]

◆ has_valid_cluster_sequence()

◆ has_valid_cs()

◆ is_inside()

◆ kt2()

◆ kt_distance()

◆ m()

◆ m2()

◆ modp()

◆ modp2()

◆ mperp()

◆ mperp2()

◆ mt()

◆ mt2()

◆ n_exclusive_subjets()

◆ operator()()

◆ operator*=()

◆ operator+=()

◆ operator-=()

◆ operator/=()

◆ operator[]()

◆ perp()

◆ perp2()

◆ phi()

◆ phi_02pi()