#include <Qjets.h>

Collaboration diagram for JetSubStructureUtils::Qjets:

Public Member Functions
	Qjets (double zcut, double dcut_fctr, double exp_min, double exp_max, double rigidity, double truncation_fctr)

void	Cluster (fastjet::ClusterSequence &cs)

void	SetRandSeed (unsigned int seed)

Private Member Functions
double	d_ij (const fastjet::PseudoJet &v1, const fastjet::PseudoJet &v2) const

void	ComputeDCut (fastjet::ClusterSequence &cs)

double	Rand ()

bool	Prune (jet_distance &jd, fastjet::ClusterSequence &cs)

bool	JetsUnmerged (const jet_distance &jd) const

bool	JetUnmerged (int num) const

void	ComputeNewDistanceMeasures (fastjet::ClusterSequence &cs, int new_jet)

void	ComputeAllDistances (const std::vector< fastjet::PseudoJet > &inp)

double	ComputeMinimumDistance ()

double	ComputeNormalization (double dmin)

jet_distance	GetNextDistance ()

bool	Same (const jet_distance &lhs, const jet_distance &rhs)

Private Attributes
TRandom3	m_rand

double	m_zcut

double	m_dcut

double	m_dcut_fctr

double	m_exp_min

double	m_exp_max

double	m_rigidity

double	m_truncation_fctr

std::map< int, bool >	m_merged_jets

std::priority_queue< jet_distance, std::vector< jet_distance >, JetDistanceCompare >	m_distances

Detailed Description

Definition at line 31 of file Qjets.h.

Constructor & Destructor Documentation

◆ Qjets()

Qjets::Qjets	(	double	zcut,
		double	dcut_fctr,
		double	exp_min,
		double	exp_max,
		double	rigidity,
		double	truncation_fctr
	)

Definition at line 10 of file Qjets.cxx.

 : m_rand(),
   m_zcut(zcut), 
   m_dcut(-1.), 
   m_dcut_fctr(dcut_fctr),
   m_exp_min(exp_min),
   m_exp_max(exp_max),
   m_rigidity(rigidity),
   m_truncation_fctr(truncation_fctr)
 {
 }

Member Function Documentation

◆ Cluster()

void Qjets::Cluster ( fastjet::ClusterSequence & cs )

Definition at line 80 of file Qjets.cxx.

                                               {
   ComputeDCut(cs);
  
   // Populate all the distances
   ComputeAllDistances(cs.jets());
   jet_distance jd = GetNextDistance();
  
   while(!m_distances.empty() && jd.dij != -1.){
     if(!Prune(jd,cs)){
       //      m_merged_jets.push_back(jd.j1);
       //      m_merged_jets.push_back(jd.j2);
       m_merged_jets[jd.j1] = true;
       m_merged_jets[jd.j2] = true;
  
       int new_jet;
       cs.plugin_record_ij_recombination(jd.j1, jd.j2, 1., new_jet);
       assert(JetUnmerged(new_jet));
       ComputeNewDistanceMeasures(cs,new_jet);
     } else {
       double j1pt = cs.jets()[jd.j1].perp();
       double j2pt = cs.jets()[jd.j2].perp();
       if(j1pt>j2pt){
         //  m_merged_jets.push_back(jd.j2);
         m_merged_jets[jd.j2] = true;
         cs.plugin_record_iB_recombination(jd.j2, 1.);
       } else {
         //  m_merged_jets.push_back(jd.j1);
         m_merged_jets[jd.j1] = true;
         cs.plugin_record_iB_recombination(jd.j1, 1.);
       }
     }
     jd = GetNextDistance();
   } 
  
   // merge remaining jets with beam
   [[maybe_unused]] int num_merged_final(0);
  
   for(unsigned int i = 0 ; i < cs.jets().size(); i++)
     if(JetUnmerged(i)){
       num_merged_final++;
       cs.plugin_record_iB_recombination(i,1.);
     }
  
   assert(num_merged_final < 2);
 }

◆ ComputeAllDistances()

void Qjets::ComputeAllDistances ( const std::vector< fastjet::PseudoJet > & inp )

private

Definition at line 144 of file Qjets.cxx.

                                                                   {
   for(unsigned int i = 0 ; i < inp.size()-1; i++){
     // jet-jet distances
     for(unsigned int j = i+1 ; j < inp.size(); j++){
       jet_distance jd{};
       jd.j1 = i;
       jd.j2 = j;
       if(jd.j1 != jd.j2){
         jd.dij = d_ij(inp[i],inp[j]);
         m_distances.push(jd);
       }
     }    
   }
 }

◆ ComputeDCut()

void Qjets::ComputeDCut ( fastjet::ClusterSequence & cs )

private

Definition at line 126 of file Qjets.cxx.

                                                   {
   // assume all jets in cs form a single jet.  compute mass and pt
   fastjet::PseudoJet sum(0.,0.,0.,0.);
   for(vector<fastjet::PseudoJet>::const_iterator it = cs.jets().begin(); it != cs.jets().end(); ++it)
     sum += (*it);
   m_dcut = 2. * m_dcut_fctr * sum.m()/sum.perp(); 
 }

◆ ComputeMinimumDistance()

double JetSubStructureUtils::Qjets::ComputeMinimumDistance ( )

private

◆ ComputeNewDistanceMeasures()

void Qjets::ComputeNewDistanceMeasures	(	fastjet::ClusterSequence &	cs,
		int	new_jet
	)

private

Definition at line 159 of file Qjets.cxx.

                                                                               {
   // jet-jet distances
   for(unsigned int i = 0; i < cs.jets().size(); i++)
     if(JetUnmerged(i) && ((int)i) != new_jet){
       jet_distance jd{};
       jd.j1 = new_jet;
       jd.j2 = i;
       jd.dij = d_ij(cs.jets()[jd.j1], cs.jets()[jd.j2]);
       m_distances.push(jd);
     }
 }

◆ ComputeNormalization()

double JetSubStructureUtils::Qjets::ComputeNormalization ( double dmin )

private

◆ d_ij()

double Qjets::d_ij	(	const fastjet::PseudoJet &	v1,
		const fastjet::PseudoJet &	v2
	)		const

private

Definition at line 171 of file Qjets.cxx.

                                                                               {
   double p1 = v1.perp();
   double p2 = v2.perp();
   double ret = pow(min(p1,p2),m_exp_min) * pow(max(p1,p2),m_exp_max) * v1.squared_distance(v2);
   assert(!std::isnan(ret));
   return ret; 
 }

◆ GetNextDistance()

jet_distance Qjets::GetNextDistance ( )

private

Definition at line 34 of file Qjets.cxx.

                                    {
   vector< pair<jet_distance, double> > popped_distances;
   double norm(0.);
   jet_distance ret{};
   ret.j1 = -1;
   ret.j2 = -1;
   ret.dij = -1.;
   bool dmin_set(false);
   double dmin(0.);
  
   while(!m_distances.empty()){
     jet_distance dist = m_distances.top();
     m_distances.pop();
     if(JetsUnmerged(dist)){
       if(!dmin_set){
         dmin = dist.dij;
         dmin_set = true;
       }
       double weight = exp(-m_rigidity * (dist.dij-dmin) /dmin);
       popped_distances.emplace_back(dist,weight);        
       norm += weight; 
       if(weight/norm < m_truncation_fctr)
         break;            
     }
   }
  
   double rand(Rand()), tot_weight(0.);
   if (!popped_distances.empty()) {
     const double inv_norm = norm == 0 ? 1 : 1. / norm;
     for(vector<pair<jet_distance, double> >::iterator it = popped_distances.begin(); it != popped_distances.end(); ++it){
       tot_weight += (*it).second * inv_norm;
       if(tot_weight >= rand){
         ret = (*it).first;
         break;
       }
     }
   }
  
   // repopulate in reverse (maybe quicker?)
   for(vector<pair<jet_distance, double> >::reverse_iterator it = popped_distances.rbegin(); it != popped_distances.rend(); ++it)
     if(JetsUnmerged((*it).first))
       m_distances.push((*it).first);
  
   return ret;
 }

◆ JetsUnmerged()

bool Qjets::JetsUnmerged ( const jet_distance & jd ) const

private

Definition at line 30 of file Qjets.cxx.

                                                     {
   return JetUnmerged(jd.j1) && JetUnmerged(jd.j2);
 }

◆ JetUnmerged()

bool Qjets::JetUnmerged ( int num ) const

private

Definition at line 26 of file Qjets.cxx.

                                     {
   return m_merged_jets.find(num) == m_merged_jets.end();
 }

◆ Prune()

bool Qjets::Prune	(	jet_distance &	jd,
		fastjet::ClusterSequence &	cs
	)

private

Definition at line 134 of file Qjets.cxx.

                                                              {
   double pt1 = cs.jets()[jd.j1].perp();
   double pt2 = cs.jets()[jd.j2].perp();
   fastjet::PseudoJet sum_jet = cs.jets()[jd.j1]+cs.jets()[jd.j2];
   double sum_pt = sum_jet.perp();
   double z = min(pt1,pt2)/sum_pt;
   double d = sqrt(cs.jets()[jd.j1].plain_distance(cs.jets()[jd.j2]));
   return (d > m_dcut) && (z < m_zcut);
 }

◆ Rand()

double Qjets::Rand ( )

private

Definition at line 179 of file Qjets.cxx.

                   {
   return m_rand.Rndm();
 }

◆ Same()

bool JetSubStructureUtils::Qjets::Same	(	const jet_distance &	lhs,
		const jet_distance &	rhs
	)

private

◆ SetRandSeed()

void Qjets::SetRandSeed ( unsigned int seed )

Definition at line 22 of file Qjets.cxx.

                                         {
   m_rand.SetSeed(seed);
 }

Member Data Documentation

◆ m_dcut

double JetSubStructureUtils::Qjets::m_dcut

private

Definition at line 34 of file Qjets.h.

◆ m_dcut_fctr

double JetSubStructureUtils::Qjets::m_dcut_fctr

private

Definition at line 34 of file Qjets.h.

◆ m_distances

std::priority_queue<jet_distance, std::vector<jet_distance>, JetDistanceCompare> JetSubStructureUtils::Qjets::m_distances

private

Definition at line 36 of file Qjets.h.

◆ m_exp_max

double JetSubStructureUtils::Qjets::m_exp_max

private

Definition at line 34 of file Qjets.h.

◆ m_exp_min

double JetSubStructureUtils::Qjets::m_exp_min

private

Definition at line 34 of file Qjets.h.

◆ m_merged_jets

std::map<int,bool> JetSubStructureUtils::Qjets::m_merged_jets

private

Definition at line 35 of file Qjets.h.

◆ m_rand

TRandom3 JetSubStructureUtils::Qjets::m_rand

private

Definition at line 33 of file Qjets.h.

◆ m_rigidity

double JetSubStructureUtils::Qjets::m_rigidity

private

Definition at line 34 of file Qjets.h.

◆ m_truncation_fctr

double JetSubStructureUtils::Qjets::m_truncation_fctr

private

Definition at line 34 of file Qjets.h.

◆ m_zcut

double JetSubStructureUtils::Qjets::m_zcut

private

Definition at line 34 of file Qjets.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Qjets()

Member Function Documentation

◆ Cluster()

◆ ComputeAllDistances()

◆ ComputeDCut()

◆ ComputeMinimumDistance()

◆ ComputeNewDistanceMeasures()

◆ ComputeNormalization()

◆ d_ij()

◆ GetNextDistance()

◆ JetsUnmerged()

◆ JetUnmerged()

◆ Prune()

◆ Rand()

◆ Same()

◆ SetRandSeed()

Member Data Documentation

◆ m_dcut

◆ m_dcut_fctr

◆ m_distances

◆ m_exp_max

◆ m_exp_min

◆ m_merged_jets

◆ m_rand

◆ m_rigidity

◆ m_truncation_fctr

◆ m_zcut