[u/mrichter/AliRoot.git] / PWGDQ / dielectron / TakuAlberica / single / AliDielectronTaku.h

#ifndef ALIDIELECTRON_H
#define ALIDIELECTRON_H
/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

//#####################################################
//#                                                   # 
//#             Class AliDielectronTaku                   #
//#         Main Class for e+e- analysis              #
//#                                                   #
//#  by WooJin J. Park, GSI / W.J.Park@gsi.de         #
//#     Ionut C. Arsene, GSI / I.C.Arsene@gsi.de      #
//#     Magnus Mager, CERN / Magnus.Mager@cern.ch     #
//#     Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch #
//#                                                   #
//#####################################################


#include <TNamed.h>
#include <TObjArray.h>

#include <AliAnalysisFilter.h>
#include <AliKFParticle.h>

#include "AliDielectronHistosTaku.h"

class AliVEvent;
class AliMCEvent;
class THashList;
class AliDielectronCF;
class AliDielectronDebugTreeTaku;
class AliDielectronTrackRotator;
class AliDielectronPair;
class AliDielectronSignalMC;

//________________________________________________________________
class AliDielectronTaku : public TNamed {
  
public:
  enum EPairType { kEv1PP=0, kEv1PM, kEv1MM,
      kEv1PEv2P, kEv1MEv2P, kEv2PP,
      kEv1PEv2M, kEv1MEv2M, kEv2PM,
      kEv2MM, kEv1PMRot };
  enum ELegType  { kEv1P, kEv1M, kEv2P, kEv2M };
  
  AliDielectronTaku();
  AliDielectronTaku(const char* name, const char* title);
  virtual ~AliDielectronTaku();

  void Init();
  
  void Process(AliVEvent *ev1, AliVEvent *ev2=0);

  const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; }
  const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; }
  const AliAnalysisFilter& GetPairFilter()  const { return fPairFilter;  }

  AliAnalysisFilter& GetEventFilter()       { return fEventFilter;       }
  AliAnalysisFilter& GetTrackFilter()       { return fTrackFilter;       }
  AliAnalysisFilter& GetPairFilter()        { return fPairFilter;        }
  AliAnalysisFilter& GetPairPreFilter()     { return fPairPreFilter;     }
  AliAnalysisFilter& GetPairPreFilterLegs() { return fPairPreFilterLegs; }
  
  void  SetMotherPdg( Int_t pdgMother ) { fPdgMother=pdgMother; }
  void  SetLegPdg(Int_t pdgLeg1, Int_t pdgLeg2) { fPdgLeg1=pdgLeg1; fPdgLeg2=pdgLeg2; }
  Int_t GetMotherPdg() const { return fPdgMother; }
  Int_t GetLeg1Pdg()   const { return fPdgLeg1;   }
  Int_t GetLeg2Pdg()   const { return fPdgLeg2;   }

  void SetNoPairing(Bool_t noPairing=kTRUE) { fNoPairing=noPairing; }
  const TObjArray* GetTrackArray(Int_t i) const {return (i>=0&&i<4)?&fTracks[i]:0;}
  const TObjArray* GetPairArray(Int_t i)  const {return (i>=0&&i<10)?
      static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i)):0;}

  TObjArray** GetPairArraysPointer() { return &fPairCandidates; }
  
  void SetHistogramManager(AliDielectronHistosTaku * const histos) { fHistos=histos; }
  void SetTreeManager(AliDielectronHistosTaku * const histos) { fTree=histos; }
  AliDielectronHistosTaku* GetHistoManager() const { return fHistos; }
  const THashList * GetHistogramList() const { return fHistos?fHistos->GetHistogramList():0x0; }
  AliDielectronHistosTaku* GetTreeManager() const { return fTree; }
  const THashList * GetTreeList() const { return fTree?fTree->GetTreeList():0x0; }
  TTree *GetSingleTree(AliDielectronHistosTaku *fTreeHisto) const {return fTreeHisto->GetSingleTree();}

  Bool_t HasCandidates() const { return GetPairArray(1)?GetPairArray(1)->GetEntriesFast()>0:0; }
  Bool_t HasCandidatesLikeSign() const {
    return (GetPairArray(0)&&GetPairArray(2)) ? (GetPairArray(0)->GetEntriesFast()>0 || GetPairArray(2)->GetEntriesFast()>0) : 0;
  }
  
  void SetCFManagerPair(AliDielectronCF * const cf) { fCfManagerPair=cf; }
  AliDielectronCF* GetCFManagerPair() const { return fCfManagerPair; }

  void SetPreFilterUnlikeOnly(Bool_t setValue=kTRUE){fPreFilterUnlikeOnly=setValue;};
  void SetPreFilterAllSigns(Bool_t setValue=kTRUE){fPreFilterAllSigns=setValue;};

  void SetTrackRotator(AliDielectronTrackRotator * const rot) { fTrackRotator=rot; }
  AliDielectronTrackRotator* GetTrackRotator() const { return fTrackRotator; }

  void SetHasMC(Bool_t hasMC) { fHasMC = hasMC; }
  Bool_t GetHasMC() const     { return fHasMC;  }

  void AddSignalMC(AliDielectronSignalMC* signal);  

  void SetDebugTree(AliDielectronDebugTreeTaku * const tree) { fDebugTree=tree; }

  const TObjArray* GetMCSignals() const { return fSignalsMC; }
  static const char* TrackClassName(Int_t i) { return (i>=0&&i<4)?fgkTrackClassNames[i]:""; }
  static const char* PairClassName(Int_t i)  { return (i>=0&&i<11)?fgkPairClassNames[i]:""; }

  void SaveDebugTree();


  Double_t GetVarManagerVariable(Int_t n) const {return fgData[n];}
  
private:
  
  AliAnalysisFilter fEventFilter;    // Event cuts
  AliAnalysisFilter fTrackFilter;    // leg cuts
  AliAnalysisFilter fPairPreFilter;  // pair prefilter cuts
  AliAnalysisFilter fPairPreFilterLegs; // Leg filter after the pair prefilter cuts
  AliAnalysisFilter fPairFilter;     // pair cuts
  
  Int_t fPdgMother;     // pdg code of mother tracks
  Int_t fPdgLeg1;       // pdg code leg1
  Int_t fPdgLeg2;       // pdg code leg2

  TObjArray* fSignalsMC;      // array of AliDielectronSignalMC

  Bool_t fNoPairing;    // if to skip pairing, can be used for track QA only
    
  AliDielectronHistosTaku *fHistos;   // Histogram manager
                                  //  Streaming and merging should be handled
                                  //  by the analysis framework

  AliDielectronHistosTaku *fTree;   // This is for tree
                                  //  Streaming and merging should be handled
                                  //  by the analysis framework

 
  TObjArray fTracks[4];           //! Selected track candidates
                                  //  0: Event1, positive particles
                                  //  1: Event1, negative particles
                                  //  2: Event2, positive particles
                                  //  3: Event2, negative particles

  TObjArray *fPairCandidates;     //! Pair candidate arrays
                                  //TODO: better way to store it? TClonesArray?

  AliDielectronCF *fCfManagerPair;//Correction Framework Manager for the Pair
  AliDielectronTrackRotator *fTrackRotator; //Track rotator
  AliDielectronDebugTreeTaku *fDebugTree;  // Debug tree output

  Bool_t fPreFilterUnlikeOnly;  //Apply PreFilter either in +- or to ++/--/+- individually
  Bool_t fPreFilterAllSigns;  //Apply PreFilter find in  ++/--/+- and remove from all
  Bool_t fHasMC;                //If we run with MC, at the moment only needed in AOD
  
  void FillTrackArrays(AliVEvent * const ev, Int_t eventNr=0);
  void PairPreFilter(Int_t arr1, Int_t arr2, TObjArray &arrTracks1, TObjArray &arrTracks2);
  void FillPairArrays(Int_t arr1, Int_t arr2);
  void FillPairArrayTR();
  
  Int_t GetPairIndex(Int_t arr1, Int_t arr2) const {return arr1>=arr2?arr1*(arr1+1)/2+arr2:arr2*(arr2+1)/2+arr1;}

  void InitPairCandidateArrays();
  void ClearArrays();
  
  TObjArray* PairArray(Int_t i);
  
  static const char* fgkTrackClassNames[4];   //Names for track arrays
  static const char* fgkPairClassNames[11];   //Names for pair arrays

  void ProcessMC();
  
  void  FillHistograms(const AliVEvent *ev);
  void  FillTree(const AliVEvent *ev);
  void  FillHistogramsMC(const AliMCEvent *ev);
  void  FillHistogramsPair(AliDielectronPair *pair,Bool_t fromPreFilter=kFALSE);
  void  FillHistogramsTracks(TObjArray **tracks);

  void  FillDebugTree();
  
  AliDielectronTaku(const AliDielectronTaku &c);
  AliDielectronTaku &operator=(const AliDielectronTaku &c);

  Double_t fgData[AliDielectronVarManager::kNMaxValues];

  
  ClassDef(AliDielectronTaku,4);
};

inline void AliDielectronTaku::InitPairCandidateArrays()
{
  //
  // initialise all pair candidate arrays
  //
  fPairCandidates->SetOwner();
  for (Int_t i=0;i<10;++i){
    TObjArray *arr=new TObjArray;
    fPairCandidates->AddAt(arr,i);
    arr->SetOwner();
  }
}

inline TObjArray* AliDielectronTaku::PairArray(Int_t i)
{
  //
  // for internal use only: unchecked return of track array for fast access
  //
  return static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i));
}

inline void AliDielectronTaku::ClearArrays()
{
  //
  // Reset the Arrays
  //
  for (Int_t i=0;i<4;++i){
    fTracks[i].Clear();
  }
  for (Int_t i=0;i<10;++i){
    PairArray(i)->Delete();
  }


}

#endif
Commit	Line	Data
06f630bb	1	#ifndef ALIDIELECTRON_H
	2	#define ALIDIELECTRON_H
	3	/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	//#####################################################
	7	//# #
	8	//# Class AliDielectronTaku #
	9	//# Main Class for e+e- analysis #
	10	//# #
	11	//# by WooJin J. Park, GSI / W.J.Park@gsi.de #
	12	//# Ionut C. Arsene, GSI / I.C.Arsene@gsi.de #
	13	//# Magnus Mager, CERN / Magnus.Mager@cern.ch #
	14	//# Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch #
	15	//# #
	16	//#####################################################
	17
	18
	19	#include <TNamed.h>
	20	#include <TObjArray.h>
	21
	22	#include <AliAnalysisFilter.h>
	23	#include <AliKFParticle.h>
	24
	25	#include "AliDielectronHistosTaku.h"
	26
	27	class AliVEvent;
	28	class AliMCEvent;
	29	class THashList;
	30	class AliDielectronCF;
	31	class AliDielectronDebugTreeTaku;
	32	class AliDielectronTrackRotator;
	33	class AliDielectronPair;
	34	class AliDielectronSignalMC;
	35
	36	//________________________________________________________________
	37	class AliDielectronTaku : public TNamed {
	38
	39	public:
	40	enum EPairType { kEv1PP=0, kEv1PM, kEv1MM,
	41	kEv1PEv2P, kEv1MEv2P, kEv2PP,
	42	kEv1PEv2M, kEv1MEv2M, kEv2PM,
	43	kEv2MM, kEv1PMRot };
	44	enum ELegType { kEv1P, kEv1M, kEv2P, kEv2M };
	45
	46	AliDielectronTaku();
	47	AliDielectronTaku(const char* name, const char* title);
	48	virtual ~AliDielectronTaku();
	49
	50	void Init();
	51
	52	void Process(AliVEvent ev1, AliVEvent ev2=0);
	53
	54	const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; }
	55	const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; }
	56	const AliAnalysisFilter& GetPairFilter() const { return fPairFilter; }
	57
	58	AliAnalysisFilter& GetEventFilter() { return fEventFilter; }
	59	AliAnalysisFilter& GetTrackFilter() { return fTrackFilter; }
	60	AliAnalysisFilter& GetPairFilter() { return fPairFilter; }
	61	AliAnalysisFilter& GetPairPreFilter() { return fPairPreFilter; }
	62	AliAnalysisFilter& GetPairPreFilterLegs() { return fPairPreFilterLegs; }
	63
	64	void SetMotherPdg( Int_t pdgMother ) { fPdgMother=pdgMother; }
65	void SetLegPdg(Int_t pdgLeg1, Int_t pdgLeg2) { fPdgLeg1=pdgLeg1; fPdgLeg2=pdgLeg2; }
66	Int_t GetMotherPdg() const { return fPdgMother; }
67	Int_t GetLeg1Pdg() const { return fPdgLeg1; }
68	Int_t GetLeg2Pdg() const { return fPdgLeg2; }
69
70	void SetNoPairing(Bool_t noPairing=kTRUE) { fNoPairing=noPairing; }
71	const TObjArray* GetTrackArray(Int_t i) const {return (i>=0&&i<4)?&fTracks[i]:0;}
72	const TObjArray* GetPairArray(Int_t i) const {return (i>=0&&i<10)?
73	static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i)):0;}
74
75	TObjArray** GetPairArraysPointer() { return &fPairCandidates; }
76
77	void SetHistogramManager(AliDielectronHistosTaku * const histos) { fHistos=histos; }
78	void SetTreeManager(AliDielectronHistosTaku * const histos) { fTree=histos; }
79	AliDielectronHistosTaku* GetHistoManager() const { return fHistos; }
80	const THashList * GetHistogramList() const { return fHistos?fHistos->GetHistogramList():0x0; }
81	AliDielectronHistosTaku* GetTreeManager() const { return fTree; }
82	const THashList * GetTreeList() const { return fTree?fTree->GetTreeList():0x0; }
83	TTree GetSingleTree(AliDielectronHistosTaku fTreeHisto) const {return fTreeHisto->GetSingleTree();}
84
85	Bool_t HasCandidates() const { return GetPairArray(1)?GetPairArray(1)->GetEntriesFast()>0:0; }
86	Bool_t HasCandidatesLikeSign() const {
87	return (GetPairArray(0)&&GetPairArray(2)) ? (GetPairArray(0)->GetEntriesFast()>0 \|\| GetPairArray(2)->GetEntriesFast()>0) : 0;
88	}
89
90	void SetCFManagerPair(AliDielectronCF * const cf) { fCfManagerPair=cf; }
91	AliDielectronCF* GetCFManagerPair() const { return fCfManagerPair; }
92
93	void SetPreFilterUnlikeOnly(Bool_t setValue=kTRUE){fPreFilterUnlikeOnly=setValue;};
94	void SetPreFilterAllSigns(Bool_t setValue=kTRUE){fPreFilterAllSigns=setValue;};
95
96	void SetTrackRotator(AliDielectronTrackRotator * const rot) { fTrackRotator=rot; }
97	AliDielectronTrackRotator* GetTrackRotator() const { return fTrackRotator; }
98
99	void SetHasMC(Bool_t hasMC) { fHasMC = hasMC; }
100	Bool_t GetHasMC() const { return fHasMC; }
101
102	void AddSignalMC(AliDielectronSignalMC* signal);
103
104	void SetDebugTree(AliDielectronDebugTreeTaku * const tree) { fDebugTree=tree; }
105
106	const TObjArray* GetMCSignals() const { return fSignalsMC; }
107	static const char* TrackClassName(Int_t i) { return (i>=0&&i<4)?fgkTrackClassNames[i]:""; }
108	static const char* PairClassName(Int_t i) { return (i>=0&&i<11)?fgkPairClassNames[i]:""; }
109
110	void SaveDebugTree();
111
112
113	Double_t GetVarManagerVariable(Int_t n) const {return fgData[n];}
114
115	private:
116
117	AliAnalysisFilter fEventFilter; // Event cuts
118	AliAnalysisFilter fTrackFilter; // leg cuts
119	AliAnalysisFilter fPairPreFilter; // pair prefilter cuts
120	AliAnalysisFilter fPairPreFilterLegs; // Leg filter after the pair prefilter cuts
121	AliAnalysisFilter fPairFilter; // pair cuts
122
123	Int_t fPdgMother; // pdg code of mother tracks
124	Int_t fPdgLeg1; // pdg code leg1
125	Int_t fPdgLeg2; // pdg code leg2
126
127	TObjArray* fSignalsMC; // array of AliDielectronSignalMC
128
129	Bool_t fNoPairing; // if to skip pairing, can be used for track QA only
130
131	AliDielectronHistosTaku *fHistos; // Histogram manager
132	// Streaming and merging should be handled
133	// by the analysis framework
134
135	AliDielectronHistosTaku *fTree; // This is for tree
136	// Streaming and merging should be handled
137	// by the analysis framework
138
139
140	TObjArray fTracks[4]; //! Selected track candidates
141	// 0: Event1, positive particles
142	// 1: Event1, negative particles
143	// 2: Event2, positive particles
144	// 3: Event2, negative particles
145
146	TObjArray *fPairCandidates; //! Pair candidate arrays
147	//TODO: better way to store it? TClonesArray?
148
149	AliDielectronCF *fCfManagerPair;//Correction Framework Manager for the Pair
150	AliDielectronTrackRotator *fTrackRotator; //Track rotator
151	AliDielectronDebugTreeTaku *fDebugTree; // Debug tree output
152
153	Bool_t fPreFilterUnlikeOnly; //Apply PreFilter either in +- or to ++/--/+- individually
154	Bool_t fPreFilterAllSigns; //Apply PreFilter find in ++/--/+- and remove from all
155	Bool_t fHasMC; //If we run with MC, at the moment only needed in AOD
156
157	void FillTrackArrays(AliVEvent * const ev, Int_t eventNr=0);
158	void PairPreFilter(Int_t arr1, Int_t arr2, TObjArray &arrTracks1, TObjArray &arrTracks2);
159	void FillPairArrays(Int_t arr1, Int_t arr2);
160	void FillPairArrayTR();
161
162	Int_t GetPairIndex(Int_t arr1, Int_t arr2) const {return arr1>=arr2?arr1(arr1+1)/2+arr2:arr2(arr2+1)/2+arr1;}
163
164	void InitPairCandidateArrays();
165	void ClearArrays();
166
167	TObjArray* PairArray(Int_t i);
168
169	static const char* fgkTrackClassNames[4]; //Names for track arrays
170	static const char* fgkPairClassNames[11]; //Names for pair arrays
171
172	void ProcessMC();
173
174	void FillHistograms(const AliVEvent *ev);
175	void FillTree(const AliVEvent *ev);
176	void FillHistogramsMC(const AliMCEvent *ev);
177	void FillHistogramsPair(AliDielectronPair *pair,Bool_t fromPreFilter=kFALSE);
178	void FillHistogramsTracks(TObjArray **tracks);
179
180	void FillDebugTree();
181
182	AliDielectronTaku(const AliDielectronTaku &c);
183	AliDielectronTaku &operator=(const AliDielectronTaku &c);
184
185	Double_t fgData[AliDielectronVarManager::kNMaxValues];
186
187
188	ClassDef(AliDielectronTaku,4);
189	};
190
191	inline void AliDielectronTaku::InitPairCandidateArrays()
192	{
193	//
194	// initialise all pair candidate arrays
195	//
196	fPairCandidates->SetOwner();
197	for (Int_t i=0;i<10;++i){
198	TObjArray *arr=new TObjArray;
199	fPairCandidates->AddAt(arr,i);
200	arr->SetOwner();
201	}
202	}
203
204	inline TObjArray* AliDielectronTaku::PairArray(Int_t i)
205	{
206	//
207	// for internal use only: unchecked return of track array for fast access
208	//
209	return static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i));
210	}
211
212	inline void AliDielectronTaku::ClearArrays()
213	{
214	//
215	// Reset the Arrays
216	//
217	for (Int_t i=0;i<4;++i){
218	fTracks[i].Clear();
219	}
220	for (Int_t i=0;i<10;++i){
221	PairArray(i)->Delete();
222	}
223
224
225
226
227	}
228
229	#endif