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

#ifndef ALIANALYSISTASKEMCALJETMASSRESPONSE_H
#define ALIANALYSISTASKEMCALJETMASSRESPONSE_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;

#include "AliAnalysisTaskEmcalJet.h"

class AliAnalysisTaskEmcalJetMassResponse : public AliAnalysisTaskEmcalJet {
 public:

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

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

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

  void SetJetContainerBase(Int_t c)                             { fContainerBase     = c   ; }
  void SetMinFractionShared(Double_t f)                         { fMinFractionShared = f   ; }
  void SetJetMassAverageFunc(TF1 *f)                            { f1JetMassAvg       = f   ; }
  void SetSingleTrackEmbedding(Bool_t b)                        { fSingleTrackEmb    = b   ; }
  void SetSubtractMasslessParticleJet(Bool_t b)                 { fSubtractMassless  = b   ; }

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

  TLorentzVector                      GetSubtractedVector(AliEmcalJet *jet);
  TLorentzVector                      GetSubtractedVectorCheat(AliEmcalJet *jet);
  TLorentzVector                      GetBkgVector(AliEmcalJet *jet, AliJetContainer *cont);
  TLorentzVector                      GetBkgVectorCheat(AliEmcalJet *jet);
  Double_t                            GetJetMass(AliEmcalJet *jet);
  Double_t                            GetJetMassMasslessConstituents(AliEmcalJet *jet);
  AliVParticle*                       GetEmbeddedConstituent(AliEmcalJet *jet);

  Int_t                               fContainerBase;              // jets to be analyzed
  Double_t                            fMinFractionShared;          // only fill histos for jets if shared fraction larger than X
  TF1                                *f1JetMassAvg;                // parametrization of average jet mass
  Bool_t                              fSingleTrackEmb;             // single track embedding
  Bool_t                              fSubtractMassless;           // subtract mass of jet assuming massless particles
  Bool_t                              fCreateTree;                 // create output tree

  TH2F            **fh2PtJet1DeltaMNoSub;                          //!pt jet1 vs delta-pt vs delta-M
  TH2F            **fh2PtJet2DeltaMNoSub;                          //!pt jet2 vs delta-pt vs delta-M

  TH3F            **fh3PtJet1DeltaPtDeltaMCheat;                   //!pt jet1 vs delta-pt vs delta-M
  TH3F            **fh3PtJet2DeltaPtDeltaMCheat;                   //!pt jet2 vs delta-pt vs delta-M

  TH3F            **fh3PtJet1DeltaPtDeltaM;                        //!pt jet1 vs delta-pt vs delta-M
  TH3F            **fh3PtJet2DeltaPtDeltaM;                        //!pt jet2 vs delta-pt vs delta-M
  TH2F            **fh2PtJet1DeltaE;                               //!pt jet1 vs delta-E
  TH2F            **fh2PtJet2DeltaE;                               //!pt jet2 vs delta-E
  TH2F            **fh2PtJet1DeltaP;                               //!pt jet1 vs delta-P
  TH2F            **fh2PtJet2DeltaP;                               //!pt jet2 vs delta-P
  TH2F            **fh2PtJet2DeltaM;                               //!pt jet2 vs delta-M
  TH3F            **fh3PtJet1MJet1MJet2;                           //!pt jet1 vs jet mass jet1 vs jet mass jet2
  TH3F            **fh3PtJet2MJet1MJet2;                           //!pt jet2 vs jet mass jet1 vs jet mass jet2

  TH3F            **fh3PtJet1DeltaPtDeltaMRho;                     //!pt jet1 vs delta-pt vs delta-M
  TH2F            **fh2PtJet1DeltaERho;                            //!pt jet1 vs delta-E
  TH3F            **fh3PtJet2DeltaPtDeltaMRho;                     //!pt jet2 vs delta-pt vs delta-M
  TH2F            **fh2PtJet2DeltaPxRho;                           //!pt jet2 vs delta-px
  TH2F            **fh2PtJet2DeltaPyRho;                           //!pt jet2 vs delta-py
  TH2F            **fh2PtJet2DeltaPzRho;                           //!pt jet2 vs delta-pz
  TH2F            **fh2PtJet2DeltaERho;                            //!pt jet2 vs delta-E
  TH2F            **fh2PtJet2DeltaMRho;                            //!pt jet2 vs delta-M
  TH2F            **fh2PtJet2DeltaPtRho;                           //!pt jet2 vs delta-pT
  TH3F            **fh3PtJet2DeltaEDeltaMRho;                      //!pt jet2 vs delta-E vs delta-M
  TH3F            **fh3PtJet2DeltaPDeltaMRho;                      //!pt jet2 vs delta-P vs delta-M

  TH2F            **fh2PtJet1DeltaPtVecSub;                        //!pt jet1 (AA) vs delta pT while using vector subtraction

  TTree           *fTreeJetBkg;                                    //!tree with jet and bkg variables
  TLorentzVector  *fJet1Vec;                                       // jet1(AA) vector  
  TLorentzVector  *fJet2Vec;                                       // jet2(probe) vector
  TLorentzVector  *fBkgVec;                                        // bkg 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         fJetMassMassless;                                // jet mass for massless constituents

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

  ClassDef(AliAnalysisTaskEmcalJetMassResponse, 1)
};
#endif
Commit	Line	Data
1ea3d0d4	1	#ifndef ALIANALYSISTASKEMCALJETMASSRESPONSE_H
	2	#define ALIANALYSISTASKEMCALJETMASSRESPONSE_H
	3
	4	class TH1;
	5	class TH2;
	6	class TH3;
	7	class TH3F;
	8	class THnSparse;
bda6a83f	9	class TF1;
bda6a83f	10	class TLorentzVector;
1ea3d0d4	11	class TClonesArray;
1ea3d0d4	12	class TArrayI;
4d3b366f	13	class TTree;
4d3b366f	14	class TLorentzVector;
1ea3d0d4	15	class AliAnalysisManager;
4d3b366f	16	class AliVParticle;
1ea3d0d4	17	class AliJetContainer;
	18
	19	#include "AliAnalysisTaskEmcalJet.h"
	20
	21	class AliAnalysisTaskEmcalJetMassResponse : public AliAnalysisTaskEmcalJet {
	22	public:
	23
	24	AliAnalysisTaskEmcalJetMassResponse();
	25	AliAnalysisTaskEmcalJetMassResponse(const char *name);
	26	virtual ~AliAnalysisTaskEmcalJetMassResponse();
	27
	28	void UserCreateOutputObjects();
	29	void Terminate(Option_t *option);
	30
	31	//Setters
4d3b366f	32	void SetCreateTree(Bool_t b) { fCreateTree = b ; }
4d3b366f	33
1ea3d0d4	34	void SetJetContainerBase(Int_t c) { fContainerBase = c ; }
1ea3d0d4	35	void SetMinFractionShared(Double_t f) { fMinFractionShared = f ; }
bda6a83f	36	void SetJetMassAverageFunc(TF1 *f) { f1JetMassAvg = f ; }
4d3b366f	37	void SetSingleTrackEmbedding(Bool_t b) { fSingleTrackEmb = b ; }
4d3b366f	38	void SetSubtractMasslessParticleJet(Bool_t b) { fSubtractMassless = b ; }
1ea3d0d4	39
	40	protected:
	41	Bool_t RetrieveEventObjects();
	42	Bool_t Run();
	43	Bool_t FillHistograms();
	44
bda6a83f	45	TLorentzVector GetSubtractedVector(AliEmcalJet *jet);
bda6a83f	46	TLorentzVector GetSubtractedVectorCheat(AliEmcalJet *jet);
4d3b366f	47	TLorentzVector GetBkgVector(AliEmcalJet jet, AliJetContainer cont);
4d3b366f	48	TLorentzVector GetBkgVectorCheat(AliEmcalJet *jet);
1ea3d0d4	49	Double_t GetJetMass(AliEmcalJet *jet);
4d3b366f	50	Double_t GetJetMassMasslessConstituents(AliEmcalJet *jet);
4d3b366f	51	AliVParticle* GetEmbeddedConstituent(AliEmcalJet *jet);
1ea3d0d4	52
	53	Int_t fContainerBase; // jets to be analyzed
	54	Double_t fMinFractionShared; // only fill histos for jets if shared fraction larger than X
bda6a83f	55	TF1 *f1JetMassAvg; // parametrization of average jet mass
4d3b366f	56	Bool_t fSingleTrackEmb; // single track embedding
	57	Bool_t fSubtractMassless; // subtract mass of jet assuming massless particles
	58	Bool_t fCreateTree; // create output tree
bda6a83f	59
	60	TH2F **fh2PtJet1DeltaMNoSub; //!pt jet1 vs delta-pt vs delta-M
	61	TH2F **fh2PtJet2DeltaMNoSub; //!pt jet2 vs delta-pt vs delta-M
	62
	63	TH3F **fh3PtJet1DeltaPtDeltaMCheat; //!pt jet1 vs delta-pt vs delta-M
	64	TH3F **fh3PtJet2DeltaPtDeltaMCheat; //!pt jet2 vs delta-pt vs delta-M
1ea3d0d4	65
	66	TH3F **fh3PtJet1DeltaPtDeltaM; //!pt jet1 vs delta-pt vs delta-M
	67	TH3F **fh3PtJet2DeltaPtDeltaM; //!pt jet2 vs delta-pt vs delta-M
4d3b366f	68	TH2F **fh2PtJet1DeltaE; //!pt jet1 vs delta-E
	69	TH2F **fh2PtJet2DeltaE; //!pt jet2 vs delta-E
	70	TH2F **fh2PtJet1DeltaP; //!pt jet1 vs delta-P
	71	TH2F **fh2PtJet2DeltaP; //!pt jet2 vs delta-P
	72	TH2F **fh2PtJet2DeltaM; //!pt jet2 vs delta-M
1ea3d0d4	73	TH3F **fh3PtJet1MJet1MJet2; //!pt jet1 vs jet mass jet1 vs jet mass jet2
	74	TH3F **fh3PtJet2MJet1MJet2; //!pt jet2 vs jet mass jet1 vs jet mass jet2
	75
4d3b366f	76	TH3F **fh3PtJet1DeltaPtDeltaMRho; //!pt jet1 vs delta-pt vs delta-M
	77	TH2F **fh2PtJet1DeltaERho; //!pt jet1 vs delta-E
	78	TH3F **fh3PtJet2DeltaPtDeltaMRho; //!pt jet2 vs delta-pt vs delta-M
	79	TH2F **fh2PtJet2DeltaPxRho; //!pt jet2 vs delta-px
	80	TH2F **fh2PtJet2DeltaPyRho; //!pt jet2 vs delta-py
	81	TH2F **fh2PtJet2DeltaPzRho; //!pt jet2 vs delta-pz
	82	TH2F **fh2PtJet2DeltaERho; //!pt jet2 vs delta-E
	83	TH2F **fh2PtJet2DeltaMRho; //!pt jet2 vs delta-M
	84	TH2F **fh2PtJet2DeltaPtRho; //!pt jet2 vs delta-pT
	85	TH3F **fh3PtJet2DeltaEDeltaMRho; //!pt jet2 vs delta-E vs delta-M
	86	TH3F **fh3PtJet2DeltaPDeltaMRho; //!pt jet2 vs delta-P vs delta-M
	87
bda6a83f	88	TH2F **fh2PtJet1DeltaPtVecSub; //!pt jet1 (AA) vs delta pT while using vector subtraction
bda6a83f	89
4d3b366f	90	TTree *fTreeJetBkg; //!tree with jet and bkg variables
	91	TLorentzVector *fJet1Vec; // jet1(AA) vector
	92	TLorentzVector *fJet2Vec; // jet2(probe) vector
	93	TLorentzVector *fBkgVec; // bkg vector
	94	Float_t fArea; // area
	95	Float_t fAreaPhi; // area phi
	96	Float_t fAreaEta; // area eta
	97	Float_t fRho; // rho
	98	Float_t fRhoM; // rho_m
	99	Int_t fNConst; // N constituents in jet1
	100	Float_t fJetMassMassless; // jet mass for massless constituents
	101
1ea3d0d4	102	private:
	103	AliAnalysisTaskEmcalJetMassResponse(const AliAnalysisTaskEmcalJetMassResponse&); // not implemented
	104	AliAnalysisTaskEmcalJetMassResponse &operator=(const AliAnalysisTaskEmcalJetMassResponse&); // not implemented
	105
	106	ClassDef(AliAnalysisTaskEmcalJetMassResponse, 1)
	107	};
	108	#endif
	109