[u/mrichter/AliRoot.git] / PWGJE / EMCALJetTasks / UserTasks / AliAnalysisTaskJetShapeDeriv.h

#ifndef ALIANALYSISTASKJETSHAPEDERIV_H
#define ALIANALYSISTASKJETSHAPEDERIV_H

class TH1;
class TH2;
class TH3;
class TH3F;
class THnSparse;
class TF1;
class TLorentzVector;
class TClonesArray;
class TArrayI;
class TTree;
class TLorentzVector;
class AliAnalysisManager;
class AliVParticle;
class AliJetContainer;

/* namespace fastjet { */
/*   class PseudoJet; */
/*   class GenericSubtractor; */
/* } */

#include "AliAnalysisTaskEmcalJet.h"

class AliAnalysisTaskJetShapeDeriv : public AliAnalysisTaskEmcalJet {
 public:

  AliAnalysisTaskJetShapeDeriv();
  AliAnalysisTaskJetShapeDeriv(const char *name);
  virtual ~AliAnalysisTaskJetShapeDeriv();

  void                                UserCreateOutputObjects();
  void                                Terminate(Option_t *option);

  //Setters
  void SetCreateTree(Bool_t b)                                  { fCreateTree        = b   ; }

  void SetJetContainerBase(Int_t c)                             { fContainerBase     = c   ; }
  void SetJetContainerNoEmb(Int_t c)                            { fContainerNoEmb    = c   ; }
  void SetMinFractionShared(Double_t f)                         { fMinFractionShared = f   ; }
  void SetSingleTrackEmbedding(Bool_t b)                        { fSingleTrackEmb    = b   ; }

 protected:
  Bool_t                              RetrieveEventObjects();
  Bool_t                              Run();
  Bool_t                              FillHistograms();

  AliVParticle*                       GetEmbeddedConstituent(AliEmcalJet *jet);

  Int_t                               fContainerBase;              // jets to be analyzed
  Int_t                               fContainerNoEmb;             // subtracted jets from Pb-Pb only events
  Double_t                            fMinFractionShared;          // only fill histos for jets if shared fraction larger than X
  Bool_t                              fSingleTrackEmb;             // single track embedding
  Bool_t                              fCreateTree;                 // create output tree

  TTree           *fTreeJetBkg;                                    //!tree with jet and bkg variables
  TLorentzVector  *fJet1Vec;                                       // jet1(AA) vector  
  TLorentzVector  *fJet2Vec;                                       // jet2(probe) vector
  Float_t         fArea;                                           // area
  Float_t         fAreaPhi;                                        // area phi
  Float_t         fAreaEta;                                        // area eta
  Float_t         fRho;                                            // rho
  Float_t         fRhoM;                                           // rho_m
  Int_t           fNConst;                                         // N constituents in jet1
  Float_t         fM1st;                                           // 1st order subtracted jet mass
  Float_t         fM2nd;                                           // 2nd order subtracted jet mass
  Float_t         fDeriv1st;                                       // 1st derivative
  Float_t         fDeriv2nd;                                       // 2nd derivative
  Int_t           fMatch;                                          // 1: matched to MC jet; 0: no match

  TH2F          **fh2MSubMatch;                                    //! subtracted jet mass vs match index (0: no match; 1:match)
  TH2F          **fh2MSubPtRawAll;                                 //! subtracted jet mass vs subtracted jet pT
  TH2F          **fh2MSubPtRawMatch;                               //! subtracted jet mass vs subtracted jet pT for matched jets
  TH2F          **fh2MSubPtTrue;                                   //! subtracted jet mass vs true jet pT for matched jets
  TH2F          **fh2MTruePtTrue;                                  //! true jet mass vs true jet pT for matched jets
  TH2F          **fh2PtTrueDeltaM;                                 //! true jet pT vs (Msub - Mtrue)
  TH2F          **fh2PtTrueDeltaMRel;                              //! true jet pT vs (Msub - Mtrue)/Mtrue
  THnSparse     **fhnMassResponse;                                 //! Msub vs Mtrue vs PtCorr vs PtTrue

  TH2F          **fh2PtTrueSubFacV1;                               //! true pT vs -(rho+rhom)*V1
  TH2F          **fh2PtRawSubFacV1;                                //! raw pT vs -(rho+rhom)*V1
  TH2F          **fh2PtCorrSubFacV1;                               //! subtracted pT vs -(rho+rhom)*V1
  TH2F          **fh2NConstSubFacV1;                               //! N constituents vs -(rho+rhom)*V1
  TH2F          **fh2PtTrueSubFacV2;                               //! true pT vs 0.5(rho+rhom)^2*V2
  TH2F          **fh2PtRawSubFacV2;                                //! raw pT vs 0.5(rho+rhom)^2*V2
  TH2F          **fh2PtCorrSubFacV2;                               //! subtracted pT vs 0.5(rho+rhom)^2*V2
  TH2F          **fh2NConstSubFacV2;                               //! N constituents vs 0.5(rho+rhom)^2*V2

 private:
  AliAnalysisTaskJetShapeDeriv(const AliAnalysisTaskJetShapeDeriv&);            // not implemented
  AliAnalysisTaskJetShapeDeriv &operator=(const AliAnalysisTaskJetShapeDeriv&); // not implemented

  ClassDef(AliAnalysisTaskJetShapeDeriv, 2)
};
#endif
Commit	Line	Data
f4b02da3	1	#ifndef ALIANALYSISTASKJETSHAPEDERIV_H
	2	#define ALIANALYSISTASKJETSHAPEDERIV_H
	3
	4	class TH1;
	5	class TH2;
	6	class TH3;
	7	class TH3F;
	8	class THnSparse;
	9	class TF1;
	10	class TLorentzVector;
	11	class TClonesArray;
	12	class TArrayI;
	13	class TTree;
	14	class TLorentzVector;
	15	class AliAnalysisManager;
	16	class AliVParticle;
	17	class AliJetContainer;
	18
a5a1c51a	19	/* namespace fastjet { */
	20	/* class PseudoJet; */
	21	/* class GenericSubtractor; */
	22	/* } */
f4b02da3	23
	24	#include "AliAnalysisTaskEmcalJet.h"
	25
	26	class AliAnalysisTaskJetShapeDeriv : public AliAnalysisTaskEmcalJet {
	27	public:
	28
	29	AliAnalysisTaskJetShapeDeriv();
	30	AliAnalysisTaskJetShapeDeriv(const char *name);
	31	virtual ~AliAnalysisTaskJetShapeDeriv();
	32
	33	void UserCreateOutputObjects();
	34	void Terminate(Option_t *option);
	35
	36	//Setters
	37	void SetCreateTree(Bool_t b) { fCreateTree = b ; }
	38
	39	void SetJetContainerBase(Int_t c) { fContainerBase = c ; }
a5a1c51a	40	void SetJetContainerNoEmb(Int_t c) { fContainerNoEmb = c ; }
f4b02da3	41	void SetMinFractionShared(Double_t f) { fMinFractionShared = f ; }
	42	void SetSingleTrackEmbedding(Bool_t b) { fSingleTrackEmb = b ; }
	43
	44	protected:
	45	Bool_t RetrieveEventObjects();
	46	Bool_t Run();
	47	Bool_t FillHistograms();
	48
	49	AliVParticle* GetEmbeddedConstituent(AliEmcalJet *jet);
	50
	51	Int_t fContainerBase; // jets to be analyzed
a5a1c51a	52	Int_t fContainerNoEmb; // subtracted jets from Pb-Pb only events
f4b02da3	53	Double_t fMinFractionShared; // only fill histos for jets if shared fraction larger than X
	54	Bool_t fSingleTrackEmb; // single track embedding
	55	Bool_t fCreateTree; // create output tree
	56
	57	TTree *fTreeJetBkg; //!tree with jet and bkg variables
	58	TLorentzVector *fJet1Vec; // jet1(AA) vector
	59	TLorentzVector *fJet2Vec; // jet2(probe) vector
	60	Float_t fArea; // area
	61	Float_t fAreaPhi; // area phi
	62	Float_t fAreaEta; // area eta
	63	Float_t fRho; // rho
	64	Float_t fRhoM; // rho_m
	65	Int_t fNConst; // N constituents in jet1
	66	Float_t fM1st; // 1st order subtracted jet mass
	67	Float_t fM2nd; // 2nd order subtracted jet mass
	68	Float_t fDeriv1st; // 1st derivative
	69	Float_t fDeriv2nd; // 2nd derivative
	70	Int_t fMatch; // 1: matched to MC jet; 0: no match
	71
	72	TH2F **fh2MSubMatch; //! subtracted jet mass vs match index (0: no match; 1:match)
	73	TH2F **fh2MSubPtRawAll; //! subtracted jet mass vs subtracted jet pT
	74	TH2F **fh2MSubPtRawMatch; //! subtracted jet mass vs subtracted jet pT for matched jets
	75	TH2F **fh2MSubPtTrue; //! subtracted jet mass vs true jet pT for matched jets
	76	TH2F **fh2MTruePtTrue; //! true jet mass vs true jet pT for matched jets
	77	TH2F **fh2PtTrueDeltaM; //! true jet pT vs (Msub - Mtrue)
0947b103	78	TH2F **fh2PtTrueDeltaMRel; //! true jet pT vs (Msub - Mtrue)/Mtrue
f4b02da3	79	THnSparse **fhnMassResponse; //! Msub vs Mtrue vs PtCorr vs PtTrue
	80
	81	TH2F *fh2PtTrueSubFacV1; //! true pT vs -(rho+rhom)V1
	82	TH2F *fh2PtRawSubFacV1; //! raw pT vs -(rho+rhom)V1
	83	TH2F *fh2PtCorrSubFacV1; //! subtracted pT vs -(rho+rhom)V1
	84	TH2F *fh2NConstSubFacV1; //! N constituents vs -(rho+rhom)V1
	85	TH2F *fh2PtTrueSubFacV2; //! true pT vs 0.5(rho+rhom)^2V2
	86	TH2F *fh2PtRawSubFacV2; //! raw pT vs 0.5(rho+rhom)^2V2
	87	TH2F *fh2PtCorrSubFacV2; //! subtracted pT vs 0.5(rho+rhom)^2V2
	88	TH2F *fh2NConstSubFacV2; //! N constituents vs 0.5(rho+rhom)^2V2
	89
	90	private:
	91	AliAnalysisTaskJetShapeDeriv(const AliAnalysisTaskJetShapeDeriv&); // not implemented
	92	AliAnalysisTaskJetShapeDeriv &operator=(const AliAnalysisTaskJetShapeDeriv&); // not implemented
	93
a5a1c51a	94	ClassDef(AliAnalysisTaskJetShapeDeriv, 2)
f4b02da3	95	};
	96	#endif
	97
	98
	99