PHAJMaker.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file PHAJMaker.h

#ifndef PHAJMAKER_H__
#define PHAJMAKER_H__

#include <fun4all/SubsysReco.h>
#include <fun4all/Fun4AllServer.h>
#include <fun4all/Fun4AllHistoManager.h>
#include <map>
#include <set>
#include <string>
#include <vector>

#include "PJTranslator.h"

#ifndef __CINT__
#include "JetAnalyzer.hh"
#include "AjParameters.hh"
#endif // __CINT__

#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TString.h"
#include "TChain.h"

class PHCompositeNode;
class RawClusterContainer;
class SvtxTrackMap;
class TF1;

#include <assert.h>
#include <iostream>
#include <cmath>

/* namespace fastjet { */
/*   class PseudoJet; */
/*   class JetDefinition; */
/*   class SISConePlugin;     */
/*   class ClusterSequence; */
/* } */


class PHAJMaker: public SubsysReco
{
  // ------------------------------------------------------
  // ------------------- PUBLIC  --------------------------
  // ------------------------------------------------------
 public:

  PHAJMaker( const std::string &name = "PHAJMaker",
             double R = 0.4,
             double jet_ptmin = 10.0, double jet_ptmax = 100.0,
             double LeadPtMin = 20.0, double SubLeadPtMin = 10, 
             double max_track_rap = 1.0, double PtConsLo=0.2, double PtConsHi=2.0,
             double dPhiCut = 0.4
             );

  int Init(PHCompositeNode *);

  int process_event(PHCompositeNode *);

  bool Has10Gev;

  // Getters and Setters
  // -------------------
  inline double GetR ( )                   { return R; };
  inline void   SetR ( const double newv ) { R=newv;   };

  inline double GetJet_ptmin ( )                   { return jet_ptmin; };
  inline void   SetJet_ptmin ( const double newv ) { jet_ptmin=newv;   };

  inline double GetJet_ptmax ( )                   { return jet_ptmax; };
  inline void   SetJet_ptmax ( const double newv ) { jet_ptmax=newv;   };

  inline double GetMax_rap ( )                   { return max_rap; };
  inline void   SetMax_rap ( const double newv ) { max_rap=newv;   };

  inline double GetGhost_maxrap ( )                   { return ghost_maxrap; };
  inline void   SetGhost_maxrap ( const double newv ) { ghost_maxrap=newv;   };

  inline double GetDPhiCut ( )                   { return dPhiCut; };
  inline void   SetDPhiCut ( const double newv ) { dPhiCut=newv;   };  

  virtual ~PHAJMaker();

#ifndef __CINT__
  inline double CalcAj ( std::vector<fastjet::PseudoJet>& jets ){
    if ( jets.size()!=2 ){
      throw ( -1 );
      return -1e10;
    }
    return fabs (( jets.at(0).pt()-jets.at(1).pt() ) / ( jets.at(0).pt()+jets.at(1).pt() ));    
  }

  // Objects will be handed by _reference_! Obviates need for setter
  inline fastjet::JetDefinition& GetJet_def () { return jet_def; }
  inline fastjet::Selector& GetLoConsSelector () { return slo; }
  inline fastjet::Selector& GetHiConsSelector () { return shi; }
  
  inline fastjet::Selector& GetJetSelector () { return sjet; }

  inline fastjet::GhostedAreaSpec& GetArea_spec () { return area_spec; }
  inline fastjet::AreaDefinition& GetArea_def () { return area_def; }


  inline JetAnalyzer* GetJAhi() {return pJAhi; };
  inline JetAnalyzer* GetJAlo() {return pJAlo; };

  inline std::vector<fastjet::PseudoJet> GetJAhiResult() {return JAhiResult; };
  inline std::vector<fastjet::PseudoJet> GetJAloResult() {return JAloResult; };

  inline std::vector<fastjet::PseudoJet> GetLoConstituents() {return pLo; };
  inline std::vector<fastjet::PseudoJet> GetHiConstituents() {return pHi; };

  
  inline std::vector<fastjet::PseudoJet> GetDiJetsHi() {return DiJetsHi; };
  inline std::vector<fastjet::PseudoJet> GetDiJetsLo() {return DiJetsLo; };


#endif // __CINT__

  //void save_jets_to_nodetree();


  
  // ------------------------------------------------------
  // ------------------- PRIVATE --------------------------
  // ------------------------------------------------------
  private:                       

  Fun4AllHistoManager* MyHistos;
  TH2D* UnmatchedAJ_hi;
  TH2D* AJ_hi;
  TH2D* AJ_lo;

  double R;              
  double jet_ptmin;      
  double jet_ptmax;      
  double LeadPtMin;      
  double SubLeadPtMin;   
  double max_rap;        
  double ghost_maxrap;   

  double max_track_rap;  
  double PtConsLo;       
  double PtConsHi;       

  double dPhiCut;        

#ifndef __CINT__
  fastjet::JetDefinition jet_def;       
  fastjet::JetDefinition other_jet_def; 

  fastjet::Selector select_track_rap;   
  fastjet::Selector select_lopt;        
  fastjet::Selector select_hipt;        

  fastjet::Selector slo;                
  fastjet::Selector shi;                

// Relevant jet candidates
  fastjet::Selector select_jet_rap;        
  fastjet::Selector select_jet_pt_min;     
  fastjet::Selector select_jet_pt_max;     
  fastjet::Selector sjet;                  

  fastjet::GhostedAreaSpec area_spec;      
  fastjet::AreaDefinition area_def;        

  JetAnalyzer* pJAhi;                      
  JetAnalyzer* pJAlo;                      
  JetAnalyzer* pOtherJAlo;                 

  std::vector<fastjet::PseudoJet> pHi;     
  std::vector<fastjet::PseudoJet> pLo;     

  std::vector<fastjet::PseudoJet> JAhiResult;  
  std::vector<fastjet::PseudoJet> JAloResult;  
  std::vector<fastjet::PseudoJet> OtherJAloResult;  
  
  std::vector<fastjet::PseudoJet> DiJetsHi;    
  std::vector<fastjet::PseudoJet> DiJetsLo;    
  std::vector<fastjet::PseudoJet> OtherDiJetsLo; 

#endif // __CINT__


};

#endif