JetClustering.h

Go to the documentation of this file.

#ifndef FastJet_JetClustering_h
#define FastJet_JetClustering_h
 
#include <cmath>
#include <vector>
 
#include "fastjet/AreaDefinition.hh"
#include "fastjet/ClusterSequence.hh"
#include "fastjet/ClusterSequenceArea.hh"
#include "fastjet/JetDefinition.hh"
#include "fastjet/EECambridgePlugin.hh"
#include "fastjet/JadePlugin.hh"
 
#include "FastJet/ValenciaPlugin.h"
 
namespace JetClustering {
  struct FCCAnalysesJet {
    std::vector<fastjet::PseudoJet> jets;
    std::vector<std::vector<int>> constituents;
    std::vector<float>
        exclusive_dmerge;  // vector of Nmax_dmerge  values associated with merging from n + 1 to n jets, for n =1, 2, ... 10
    std::vector<float> exclusive_dmerge_max;
  };
 
 
 
  struct clustering_kt {
  public:
    clustering_kt(float arg_radius = 0.5,
                  int arg_exclusive = 0,
                  float arg_cut = 5,
                  int arg_sorted = 0,
                  int arg_recombination = 0);
    FCCAnalysesJet operator()(const std::vector<fastjet::PseudoJet>& jets);
 
  private:
    float _radius;   
    int _exclusive;  
    float _cut;  
    int _sorted;         
    int _recombination;  
    fastjet::JetAlgorithm _jetAlgorithm{fastjet::JetAlgorithm::undefined_jet_algorithm};  
    fastjet::RecombinationScheme _recombScheme;  
    fastjet::ClusterSequence _cs;                
    fastjet::JetDefinition _def;                 
  };
 
  struct clustering_antikt {
  public:
    clustering_antikt(float arg_radius = 0.5,
                      int arg_exclusive = 0,
                      float arg_cut = 5.,
                      int arg_sorted = 0,
                      int arg_recombination = 0);
    FCCAnalysesJet operator()(const std::vector<fastjet::PseudoJet>& jets);
 
  private:
    float _radius;   
    int _exclusive;  
    float _cut;  
    int _sorted;         
    int _recombination;  
    fastjet::JetAlgorithm _jetAlgorithm{fastjet::JetAlgorithm::undefined_jet_algorithm};  
    fastjet::RecombinationScheme _recombScheme;  
    fastjet::ClusterSequence _cs;                
    fastjet::JetDefinition _def;                 
  };
 
  struct clustering_cambridge {
  public:
    clustering_cambridge(float arg_radius = 0.5,
                         int arg_exclusive = 0,
                         float arg_cut = 5.,
                         int arg_sorted = 0,
                         int arg_recombination = 0);
    FCCAnalysesJet operator()(const std::vector<fastjet::PseudoJet>& jets);
 
  private:
    float _radius;   
    int _exclusive;  
    float _cut;  
    int _sorted;         
    int _recombination;  
    fastjet::JetAlgorithm _jetAlgorithm{fastjet::JetAlgorithm::undefined_jet_algorithm};  
    fastjet::RecombinationScheme _recombScheme;  
    fastjet::ClusterSequence _cs;                
    fastjet::JetDefinition _def;                 
  };
 
  struct clustering_ee_kt {
  public:
    clustering_ee_kt(int arg_exclusive = 0, float arg_cut = 5., int arg_sorted = 0, int arg_recombination = 0);
    FCCAnalysesJet operator()(const std::vector<fastjet::PseudoJet>& jets);
 
    int _exclusive;  
    float _cut;  
    int _sorted;         
    int _recombination;  
    fastjet::JetAlgorithm _jetAlgorithm{fastjet::JetAlgorithm::undefined_jet_algorithm};  
    fastjet::RecombinationScheme _recombScheme;  
    fastjet::ClusterSequence _cs;                
    fastjet::JetDefinition _def;                 
  };
 
  struct clustering_ee_genkt {
  public:
    clustering_ee_genkt(float arg_radius = 0.5,
                        int arg_exclusive = 0,
                        float arg_cut = 5.,
                        int arg_sorted = 0,
                        int arg_recombination = 0,
                        float arg_exponent = 0.);
    FCCAnalysesJet operator()(const std::vector<fastjet::PseudoJet>& jets);
 
  private:
    float _radius;   
    int _exclusive;  
    float _cut;  
    int _sorted;         
    int _recombination;  
    float _exponent;     
    fastjet::JetAlgorithm _jetAlgorithm{fastjet::JetAlgorithm::undefined_jet_algorithm};  
    fastjet::RecombinationScheme _recombScheme;  
    fastjet::ClusterSequence _cs;                
    fastjet::JetDefinition _def;                 
  };
 
  struct clustering_genkt {
  public:
    clustering_genkt(float arg_radius = 0.5,
                     int arg_exclusive = 0,
                     float arg_cut = 5.,
                     int arg_sorted = 0,
                     int arg_recombination = 0,
                     float arg_exponent = 0.);
    FCCAnalysesJet operator()(const std::vector<fastjet::PseudoJet>& jets);
 
  private:
    float _radius;   
    int _exclusive;  
    float _cut;  
    int _sorted;         
    int _recombination;  
    float _exponent;     
    fastjet::JetAlgorithm _jetAlgorithm{fastjet::JetAlgorithm::undefined_jet_algorithm};  
    fastjet::RecombinationScheme _recombScheme;  
    fastjet::ClusterSequence _cs;                
    fastjet::JetDefinition _def;                 
  };
 
  struct clustering_valencia {
  public:
    clustering_valencia(float arg_radius = 0.5,
                        int arg_exclusive = 0,
                        float arg_cut = 5.,
                        int arg_sorted = 0,
                        int arg_recombination = 0,
                        float arg_beta = 1.,
                        float arg_gamma = 1.);
    FCCAnalysesJet operator()(const std::vector<fastjet::PseudoJet>& jets);
 
  private:
    float _radius;   
    int _exclusive;  
    float _cut;  
    int _sorted;         
    int _recombination;  
    float _beta;         
    float _gamma;        
    //fastjet::JetAlgorithm _jetAlgorithm {fastjet::JetAlgorithm::undefined_jet_algorithm};///<internal jet algorithm
    fastjet::contrib::ValenciaPlugin* _jetAlgorithm;
    fastjet::RecombinationScheme _recombScheme;  
    fastjet::ClusterSequence _cs;                
    fastjet::JetDefinition _def;                 
  };
 
  struct clustering_jade {
  public:
    clustering_jade(float arg_radius = 0.5,
                    int arg_exclusive = 0,
                    float arg_cut = 5.,
                    int arg_sorted = 0,
                    int arg_recombination = 0);
    FCCAnalysesJet operator()(const std::vector<fastjet::PseudoJet>& jets);
 
  private:
    float _radius;   
    int _exclusive;  
    float _cut;  
    int _sorted;         
    int _recombination;  
    //fastjet::JetAlgorithm _jetAlgorithm {fastjet::JetAlgorithm::undefined_jet_algorithm};///<internal jet algorithm
    fastjet::JadePlugin* _jetAlgorithm;
    fastjet::RecombinationScheme _recombScheme;  
    fastjet::ClusterSequence _cs;                
    fastjet::JetDefinition _def;                 
  };
 
}  // namespace JetClustering
 
#endif