[u/mrichter/AliRoot.git] / PWGLF / STRANGENESS / Hypernuclei / AliAnalysisTaskAntiHe4.h

#ifndef ALIANALYSISTASKANTIHE4_CXX
#define ALIANALYSISTASKANTIHE4_CXX

// anti-alpha analysis
// Authors: Alexander Kalweit and Nicole Martin

class TF1;
class TH1F;
class TH2F;
class TH3F;
class AliESDEvent;
class AliESDtrackCuts;
class AliESDVertex;

#include "AliAnalysisTaskSE.h"
#include "THn.h"
#include "TH3F.h"
#include "TGraph.h"
#include "AliStack.h"

class AliAnalysisTaskAntiHe4 : public AliAnalysisTaskSE {
 public:
  AliAnalysisTaskAntiHe4();
  AliAnalysisTaskAntiHe4(const char *name);
  virtual ~AliAnalysisTaskAntiHe4() {}
  
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(const Option_t*);
  Int_t  Initialize();
  Int_t  SetupEvent();
  void   ResetEvent();

  
 private:
  AliInputEventHandler *fEventHandler;                              //  for ESDs or AODs
  AliESDEvent          *fESD;                                       //  ESD object
  TH1F                 *fHistCentralityClass10;                     //! histo to look at the centrality distribution    
  TH1F                 *fHistCentralityPercentile;                  //! histo to look at the centrality distribution 
  TH1F                 *fHistTriggerStat;                           //! Trigger statistics
  TH1F                 *fHistTriggerStatAfterEventSelection;        //! Trigger statistics
  TH3F                 *fHistDEDx;                                  //! final histograms for anti-alpha analysis
  TH3F                 *fHistTOF3D;                                 //! final histograms for anti-alpha analysis
  TH1F                 *fHistAlpha;                                 //! Alpha plot TOF mass
  TH1F                 *fHistAlphaSignal;                           //! Alpha plot TOF mass only signal candidates
  TGraph               *fGraphAlphaSignal;                          //! TGraph with alphas / dE/dx vs. mom
  Int_t                 fNCounter;                                  //! counts alphas

  TH2F                 *fHistDeDx;                                  //! histo for a dE/dx     
  TH3F                 *fHistDeDxRegion;                            //! histo for a dE/dx per Region 
  TH2F                 *fHistDeDxSharp;                             //! histo for a dE/dx with sharp cuts

  TH2F                 *fHistTOF2D;                                 //! histo for a TOF
  TH2F                 *fHistTOFnuclei;                             //! histo for a TOF nuclei  

  Int_t                 fNTriggers;                                 //! N Triggers used
  Double_t              fBBParametersLightParticles[5];             //! Bethe Bloch paramters for light paritcles
  Double_t              fBBParametersNuclei[5];                     //! Bethe Bloch paramters for nuclei
  Bool_t                fMCtrue;                                    //! flag if real data or MC is processed
  Bool_t                fTriggerFired[5];                           //! TriggerFired 0: MB | 1: CE | 2: SC | 3: EJE | 4: EGA
  //
  AliESDtrackCuts      *fESDtrackCuts;                              //  basic cut variables
  AliESDtrackCuts      *fESDtrackCutsSharp;                         //  sharp cut variables for final results
  AliESDpid            *fESDpid;                                    //  basic TPC object for n-sigma cuts
  THnF                 *fAntiAlpha;                                 //! histogram for particle ratios as a function of momentum: (0.) dca, (1.) sign, (2.) particle Type, (3.) p_tot

  TH1F                 *fHistHelium4PtGen;                          //! for MC
  TH1F                 *fHistHelium4PtGenPrim;                      //! for MC
  TH1F                 *fHistHelium4PtGenSec;                       //! for MC
  TH1F                 *fHistHelium4PtGenEta;                       //! for MC 
  TH1F                 *fHistHelium4PtGenPrimEta;                   //! for MC
  TH1F                 *fHistAntiHelium4PtGen;                      //! for MC
  TH1F                 *fHistAntiHelium4PtGenPrim;                  //! for MC                        
  TH1F                 *fHistAntiHelium4PtGenSec;                   //! for MC
  TH1F                 *fHistAntiHelium4PtGenEta;                   //! for MC
  TH1F                 *fHistHelium4PtAso;                          //! for MC
  TH1F                 *fHistHelium4PtAsoPrim;                      //! for MC
  TH1F                 *fHistHelium4PtAsoSec;                       //! for MC
  TH1F                 *fHistAntiHelium4PtAso;                      //! for MC


  void                  BinLogAxis(const THn *h, Int_t axisNumber); //  define function for log axis for search for Anti-Alpha candidates
  void                  BinLogAxis(const TH3 *h, Int_t axisNumber); 
  void                  BinLogAxis(const TH1 *h);
  Bool_t                IsTriggered();
  void                  SetBBParameters(Int_t runnumber);
  void                  MCGenerated(AliStack* stack); 

  //
  // output containers
  //
  TTree *fTree;  
  TObjArray * fOutputContainer; // ! output data container
  //
  // tree variables
  //
  Char_t fName[1000];  
  Int_t  fEvnt;
  Char_t  fFileName[1000];
  Int_t   fEventNumber[1000];
  // 
  Int_t  fItrk;
  //
  Double_t fEta[1000];
  Int_t    fKinkIndex[1000];
  //
  UShort_t   fTPCNsignal[1000];
  UShort_t   fTPCnCluster[1000];
  Double_t   fChi2PerClusterTPC[1000];
  Bool_t  fTPCRefit[1000];
  Double_t fTPCsignal0[1000];
  Double_t fTPCsignal1[1000];
  Double_t fTPCsignal2[1000];
  Double_t fTPCsignal3[1000];
  Int_t   fTPCSharedClusters[1000];
  UShort_t   fTPCNclsIter1[1000];
  //
  Double_t fITSsignal[1000];
  Int_t   fITSnCluster[1000];
  Double_t   fChi2PerClusterITS[1000];
  Bool_t  fITSRefit[1000];
  //
  Bool_t  fTOFRefit[1000];
  Bool_t  fTOFtime[1000];
  Bool_t  fTOFout[1000];
  Double_t fTOFsignalDz[1000];
  Double_t fTOFsignalDx[1000];
  //
  Float_t fDCAZ[1000];
  Float_t fDCAXY[1000];
  //
  Double_t fTrkPtot[1000];
  Double_t fTPCPtot[1000];
  Double_t fTrackPt[1000];
  Double_t fDeDx[1000];
  Double_t fSign[1000];
  Float_t fMass[1000];
  //
  Bool_t  fAssociated[1000];
 
  //
  //
  AliAnalysisTaskAntiHe4(const AliAnalysisTaskAntiHe4&); // not implemented
  AliAnalysisTaskAntiHe4& operator=(const AliAnalysisTaskAntiHe4&); // not implemented
  
  ClassDef(AliAnalysisTaskAntiHe4, 1); // example of analysis
};

#endif
Commit	Line	Data
110805a7	1	#ifndef ALIANALYSISTASKANTIHE4_CXX
	2	#define ALIANALYSISTASKANTIHE4_CXX
	3
	4	// anti-alpha analysis
	5	// Authors: Alexander Kalweit and Nicole Martin
	6
	7	class TF1;
	8	class TH1F;
	9	class TH2F;
d1f5b077	10	class TH3F;
110805a7	11	class AliESDEvent;
	12	class AliESDtrackCuts;
	13	class AliESDVertex;
	14
	15	#include "AliAnalysisTaskSE.h"
	16	#include "THn.h"
	17	#include "TH3F.h"
	18	#include "TGraph.h"
d1f5b077	19	#include "AliStack.h"
110805a7	20
	21	class AliAnalysisTaskAntiHe4 : public AliAnalysisTaskSE {
	22	public:
	23	AliAnalysisTaskAntiHe4();
	24	AliAnalysisTaskAntiHe4(const char *name);
	25	virtual ~AliAnalysisTaskAntiHe4() {}
	26
	27	virtual void UserCreateOutputObjects();
	28	virtual void UserExec(Option_t *option);
	29	virtual void Terminate(const Option_t*);
	30	Int_t Initialize();
	31	Int_t SetupEvent();
	32	void ResetEvent();
	33
	34
	35	private:
	36	AliInputEventHandler *fEventHandler; // for ESDs or AODs
	37	AliESDEvent *fESD; // ESD object
	38	TH1F *fHistCentralityClass10; //! histo to look at the centrality distribution
	39	TH1F *fHistCentralityPercentile; //! histo to look at the centrality distribution
	40	TH1F *fHistTriggerStat; //! Trigger statistics
	41	TH1F *fHistTriggerStatAfterEventSelection; //! Trigger statistics
	42	TH3F *fHistDEDx; //! final histograms for anti-alpha analysis
	43	TH3F *fHistTOF3D; //! final histograms for anti-alpha analysis
	44	TH1F *fHistAlpha; //! Alpha plot TOF mass
	45	TH1F *fHistAlphaSignal; //! Alpha plot TOF mass only signal candidates
	46	TGraph *fGraphAlphaSignal; //! TGraph with alphas / dE/dx vs. mom
	47	Int_t fNCounter; //! counts alphas
	48
	49	TH2F *fHistDeDx; //! histo for a dE/dx
	50	TH3F *fHistDeDxRegion; //! histo for a dE/dx per Region
	51	TH2F *fHistDeDxSharp; //! histo for a dE/dx with sharp cuts
	52
	53	TH2F *fHistTOF2D; //! histo for a TOF
	54	TH2F *fHistTOFnuclei; //! histo for a TOF nuclei
	55
	56	Int_t fNTriggers; //! N Triggers used
	57	Double_t fBBParametersLightParticles[5]; //! Bethe Bloch paramters for light paritcles
	58	Double_t fBBParametersNuclei[5]; //! Bethe Bloch paramters for nuclei
	59	Bool_t fMCtrue; //! flag if real data or MC is processed
	60	Bool_t fTriggerFired[5]; //! TriggerFired 0: MB \| 1: CE \| 2: SC \| 3: EJE \| 4: EGA
	61	//
	62	AliESDtrackCuts *fESDtrackCuts; // basic cut variables
	63	AliESDtrackCuts *fESDtrackCutsSharp; // sharp cut variables for final results
	64	AliESDpid *fESDpid; // basic TPC object for n-sigma cuts
	65	THnF *fAntiAlpha; //! histogram for particle ratios as a function of momentum: (0.) dca, (1.) sign, (2.) particle Type, (3.) p_tot
	66
d1f5b077	67	TH1F *fHistHelium4PtGen; //! for MC
	68	TH1F *fHistHelium4PtGenPrim; //! for MC
	69	TH1F *fHistHelium4PtGenSec; //! for MC
	70	TH1F *fHistHelium4PtGenEta; //! for MC
	71	TH1F *fHistHelium4PtGenPrimEta; //! for MC
	72	TH1F *fHistAntiHelium4PtGen; //! for MC
	73	TH1F *fHistAntiHelium4PtGenPrim; //! for MC
	74	TH1F *fHistAntiHelium4PtGenSec; //! for MC
	75	TH1F *fHistAntiHelium4PtGenEta; //! for MC
	76	TH1F *fHistHelium4PtAso; //! for MC
	77	TH1F *fHistHelium4PtAsoPrim; //! for MC
	78	TH1F *fHistHelium4PtAsoSec; //! for MC
	79	TH1F *fHistAntiHelium4PtAso; //! for MC
	80
	81
110805a7	82	void BinLogAxis(const THn *h, Int_t axisNumber); // define function for log axis for search for Anti-Alpha candidates
	83	void BinLogAxis(const TH3 *h, Int_t axisNumber);
	84	void BinLogAxis(const TH1 *h);
	85	Bool_t IsTriggered();
	86	void SetBBParameters(Int_t runnumber);
d1f5b077	87	void MCGenerated(AliStack* stack);
110805a7	88
	89	//
	90	// output containers
	91	//
	92	TTree *fTree;
	93	TObjArray * fOutputContainer; // ! output data container
	94	//
	95	// tree variables
	96	//
439dd8c8	97	Char_t fName[1000];
	98	Int_t fEvnt;
	99	Char_t fFileName[1000];
d1f5b077	100	Int_t fEventNumber[1000];
439dd8c8	101	//
	102	Int_t fItrk;
	103	//
	104	Double_t fEta[1000];
	105	Int_t fKinkIndex[1000];
	106	//
	107	UShort_t fTPCNsignal[1000];
	108	UShort_t fTPCnCluster[1000];
	109	Double_t fChi2PerClusterTPC[1000];
	110	Bool_t fTPCRefit[1000];
	111	Double_t fTPCsignal0[1000];
	112	Double_t fTPCsignal1[1000];
	113	Double_t fTPCsignal2[1000];
	114	Double_t fTPCsignal3[1000];
	115	Int_t fTPCSharedClusters[1000];
	116	UShort_t fTPCNclsIter1[1000];
	117	//
	118	Double_t fITSsignal[1000];
	119	Int_t fITSnCluster[1000];
	120	Double_t fChi2PerClusterITS[1000];
	121	Bool_t fITSRefit[1000];
	122	//
	123	Bool_t fTOFRefit[1000];
	124	Bool_t fTOFtime[1000];
	125	Bool_t fTOFout[1000];
	126	Double_t fTOFsignalDz[1000];
	127	Double_t fTOFsignalDx[1000];
	128	//
	129	Float_t fDCAZ[1000];
	130	Float_t fDCAXY[1000];
	131	//
	132	Double_t fTrkPtot[1000];
	133	Double_t fTPCPtot[1000];
	134	Double_t fTrackPt[1000];
	135	Double_t fDeDx[1000];
	136	Double_t fSign[1000];
	137	Float_t fMass[1000];
	138	//
d1f5b077	139	Bool_t fAssociated[1000];
439dd8c8	140
110805a7	141	//
	142	//
	143	AliAnalysisTaskAntiHe4(const AliAnalysisTaskAntiHe4&); // not implemented
	144	AliAnalysisTaskAntiHe4& operator=(const AliAnalysisTaskAntiHe4&); // not implemented
	145
	146	ClassDef(AliAnalysisTaskAntiHe4, 1); // example of analysis
	147	};
	148
	149	#endif