[u/mrichter/AliRoot.git] / PWGDQ / dielectron / AliDielectron.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 AliDielectron                   #
//#         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 <THnBase.h>

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

#include "AliDielectronHistos.h"
#include "AliDielectronHF.h"
#include "AliDielectronCutQA.h"

class AliEventplane;
class AliVEvent;
class AliMCEvent;
class THashList;
class AliDielectronCF;
class AliDielectronDebugTree;
class AliDielectronTrackRotator;
class AliDielectronPair;
class AliDielectronSignalMC;
class AliDielectronMixingHandler;

//________________________________________________________________
class AliDielectron : public TNamed {

  friend class AliDielectronMixingHandler; //mixing as friend class

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

  void Init();

  void Process(/*AliVEvent *ev1, */TObjArray *arr);
  Bool_t 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; }
  AliAnalysisFilter& GetEventPlanePreFilter(){ return fEventPlanePreFilter; }
  AliAnalysisFilter& GetEventPlanePOIPreFilter(){ return fEventPlanePOIPreFilter; }

  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 SetCutQA(Bool_t qa=kTRUE) { fCutQA=qa; }
  void SetNoPairing(Bool_t noPairing=kTRUE) { fNoPairing=noPairing; }
  void SetProcessLS(Bool_t doLS=kTRUE) { fProcessLS=doLS; }
  void SetUseKF(Bool_t useKF=kTRUE) { fUseKF=useKF; }
  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<11)?
      static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i)):0;}

  TObjArray** GetPairArraysPointer() { return &fPairCandidates; }
  void SetPairArraysPointer( TObjArray *arr) { fPairCandidates=arr; }
  void SetHistogramArray(AliDielectronHF * const histoarray) { fHistoArray=histoarray; }
  const TObjArray * GetHistogramArray() const { return fHistoArray?fHistoArray->GetHistArray():0x0; }
  const TObjArray * GetQAHistArray() const { return fQAmonitor?fQAmonitor->GetQAHistArray():0x0; }

  void SetHistogramManager(AliDielectronHistos * const histos) { fHistos=histos; }
  AliDielectronHistos* GetHistoManager() const { return fHistos; }
  const THashList * GetHistogramList() const { return fHistos?fHistos->GetHistogramList():0x0; }

  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;
  }
  
  Bool_t HasCandidatesTR() const {return GetPairArray(10)?GetPairArray(10)->GetEntriesFast()>0:0;} 
  void SetCFManagerPair(AliDielectronCF * const cf) { fCfManagerPair=cf; }
  AliDielectronCF* GetCFManagerPair() const { return fCfManagerPair; }

  void SetPreFilterEventPlane(Bool_t setValue=kTRUE){fPreFilterEventPlane=setValue;};
  void SetLikeSignSubEvents(Bool_t setValue=kTRUE){fLikeSignSubEvents=setValue;};
  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 SetMixingHandler(AliDielectronMixingHandler *mix) { fMixing=mix; }
  AliDielectronMixingHandler* GetMixingHandler() const { return fMixing; }

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

  void SetStoreRotatedPairs(Bool_t storeTR) {fStoreRotatedPairs = storeTR;}
  void SetDontClearArrays(Bool_t dontClearArrays=kTRUE) { fDontClearArrays=dontClearArrays; }
  Bool_t DontClearArrays() const { return fDontClearArrays; }

  void AddSignalMC(AliDielectronSignalMC* signal);  

  void SetDebugTree(AliDielectronDebugTree * 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 SetEstimatorFilename(const Char_t* filename) {fEstimatorFilename = filename;}
  void SetTRDcorrectionFilename(const Char_t* filename) {fTRDpidCorrectionFilename = filename;}
  void SetVZEROCalibrationFilename(const Char_t* filename) {fVZEROCalibrationFilename = filename;}
  void SetVZERORecenteringFilename(const Char_t* filename) {fVZERORecenteringFilename = filename;}
  void SetZDCRecenteringFilename(const Char_t* filename) {fZDCRecenteringFilename = filename;}
  void InitLegEffMap(TString filename)  { fLegEffMap=InitEffMap(filename)  ;}
  void InitPairEffMap(TString filename) { fPairEffMap=InitEffMap(filename) ;}

  void SetCentroidCorrFunction(TF1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);
  void SetWidthCorrFunction(TF1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);

  void SaveDebugTree();
  Bool_t DoEventProcess() const { return fEventProcess; }
  void SetEventProcess(Bool_t setValue=kTRUE) { fEventProcess=setValue; }
  void  FillHistogramsFromPairArray(Bool_t pairInfoOnly=kFALSE);

private:

  Bool_t fCutQA;                    // monitor cuts
  AliDielectronCutQA *fQAmonitor;   // monitoring of cuts
  TH1 *fPostPIDCntrdCorr;   // post pid correction object for centroids
  TH1 *fPostPIDWdthCorr;    // post pid correction object for widths
  THnBase *fLegEffMap;      // single electron efficiency map
  THnBase *fPairEffMap;      // pair efficiency map
  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
  AliAnalysisFilter fEventPlanePreFilter;  // event plane prefilter cuts  
  AliAnalysisFilter fEventPlanePOIPreFilter;  // PoI cuts in the event plane prefilter  

  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
  Bool_t fProcessLS; // do the like-sign pairing (default kTRUE)
  Bool_t fUseKF;    // if to skip pairing, can be used for track QA only

  AliDielectronHF *fHistoArray;   // Histogram framework
  AliDielectronHistos *fHistos;   // Histogram manager
                                  //  Streaming and merging should be handled
                                  //  by the analysis framework
  TBits *fUsedVars;               // used variables

  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
  AliDielectronDebugTree *fDebugTree;  // Debug tree output
  AliDielectronMixingHandler *fMixing; // handler for event mixing

  Bool_t fPreFilterEventPlane;  //Filter for the Eventplane determination in TPC
  Bool_t fLikeSignSubEvents;    //Option for dividing into subevents, sub1 ++ sub2 --
  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
  Bool_t fStoreRotatedPairs;    //It the rotated pairs should be stored in the pair array
  Bool_t fDontClearArrays;      //Don't clear the arrays at the end of the Process function, needed for external use of pair and tracks
  Bool_t fEventProcess;         //Process event (or pair array)

  void FillTrackArrays(AliVEvent * const ev, Int_t eventNr=0);
  void EventPlanePreFilter(Int_t arr1, Int_t arr2, TObjArray arrTracks1, TObjArray arrTracks2, const AliVEvent *ev);
  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);
  THnBase* InitEffMap(TString filename);
  
  static const char* fgkTrackClassNames[4];   //Names for track arrays
  static const char* fgkPairClassNames[11];   //Names for pair arrays

  TString fEstimatorFilename;                // name for the pp multiplicity estimators filename
  TString fTRDpidCorrectionFilename;         // name for the file containing the single particle TRD pid corrections
  TString fVZEROCalibrationFilename;         // file containing VZERO channel-by-channel calibration
  TString fVZERORecenteringFilename;         // file containing VZERO Q-vector recentering averages
  TString fZDCRecenteringFilename;         // file containing ZDCQ-vector recentering averages

  void ProcessMC(AliVEvent *ev1);
  
  void  FillHistograms(const AliVEvent *ev, Bool_t pairInfoOnly=kFALSE);
  void  FillMCHistograms(const AliVEvent *ev);
  void  FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal);
  void  FillHistogramsMC(const AliMCEvent *ev,  AliVEvent *ev1);
  void  FillHistogramsPair(AliDielectronPair *pair,Bool_t fromPreFilter=kFALSE);
  void  FillHistogramsTracks(TObjArray **tracks);

  void  FillDebugTree();

  AliDielectron(const AliDielectron &c);
  AliDielectron &operator=(const AliDielectron &c);
  
  ClassDef(AliDielectron,12);
};

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

inline TObjArray* AliDielectron::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 AliDielectron::ClearArrays()
{
  //
  // Reset the Arrays
  //
  for (Int_t i=0;i<4;++i){
    fTracks[i].Clear();
  }
  for (Int_t i=0;i<11;++i){
    if (PairArray(i)) PairArray(i)->Delete();
  }
}

#endif
Commit	Line	Data
b2a297fa	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 AliDielectron #
	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>
0b369e55	21	#include <THnBase.h>
b2a297fa	22
	23	#include <AliAnalysisFilter.h>
	24	#include <AliKFParticle.h>
	25
	26	#include "AliDielectronHistos.h"
620b34a5	27	#include "AliDielectronHF.h"
d8bb1abe	28	#include "AliDielectronCutQA.h"
b2a297fa	29
5720c765	30	class AliEventplane;
b2a297fa	31	class AliVEvent;
ba15fdfb	32	class AliMCEvent;
b2a297fa	33	class THashList;
b2a297fa	34	class AliDielectronCF;
572b0139	35	class AliDielectronDebugTree;
2a14a7b1	36	class AliDielectronTrackRotator;
ffbede40	37	class AliDielectronPair;
ba15fdfb	38	class AliDielectronSignalMC;
5720c765	39	class AliDielectronMixingHandler;
b2a297fa	40
	41	//________________________________________________________________
	42	class AliDielectron : public TNamed {
5720c765	43
	44	friend class AliDielectronMixingHandler; //mixing as friend class
	45
b2a297fa	46	public:
2a14a7b1	47	enum EPairType { kEv1PP=0, kEv1PM, kEv1MM,
	48	kEv1PEv2P, kEv1MEv2P, kEv2PP,
	49	kEv1PEv2M, kEv1MEv2M, kEv2PM,
	50	kEv2MM, kEv1PMRot };
	51	enum ELegType { kEv1P, kEv1M, kEv2P, kEv2M };
b2a297fa	52
	53	AliDielectron();
	54	AliDielectron(const char* name, const char* title);
	55	virtual ~AliDielectron();
	56
	57	void Init();
42c76bea	58
	59	void Process(/AliVEvent ev1, /TObjArray arr);
	60	Bool_t Process(AliVEvent ev1, AliVEvent ev2=0);
b2a297fa	61
b2a297fa	62	const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; }
	63	const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; }
	64	const AliAnalysisFilter& GetPairFilter() const { return fPairFilter; }
	65
61d106d3	66	AliAnalysisFilter& GetEventFilter() { return fEventFilter; }
	67	AliAnalysisFilter& GetTrackFilter() { return fTrackFilter; }
	68	AliAnalysisFilter& GetPairFilter() { return fPairFilter; }
	69	AliAnalysisFilter& GetPairPreFilter() { return fPairPreFilter; }
	70	AliAnalysisFilter& GetPairPreFilterLegs() { return fPairPreFilterLegs; }
5720c765	71	AliAnalysisFilter& GetEventPlanePreFilter(){ return fEventPlanePreFilter; }
	72	AliAnalysisFilter& GetEventPlanePOIPreFilter(){ return fEventPlanePOIPreFilter; }
	73
8df8e382	74	void SetMotherPdg( Int_t pdgMother ) { fPdgMother=pdgMother; }
	75	void SetLegPdg(Int_t pdgLeg1, Int_t pdgLeg2) { fPdgLeg1=pdgLeg1; fPdgLeg2=pdgLeg2; }
	76	Int_t GetMotherPdg() const { return fPdgMother; }
	77	Int_t GetLeg1Pdg() const { return fPdgLeg1; }
	78	Int_t GetLeg2Pdg() const { return fPdgLeg2; }
554e40f8	79
d8bb1abe	80	void SetCutQA(Bool_t qa=kTRUE) { fCutQA=qa; }
554e40f8	81	void SetNoPairing(Bool_t noPairing=kTRUE) { fNoPairing=noPairing; }
5156b880	82	void SetProcessLS(Bool_t doLS=kTRUE) { fProcessLS=doLS; }
08b801a6	83	void SetUseKF(Bool_t useKF=kTRUE) { fUseKF=useKF; }
b2a297fa	84	const TObjArray* GetTrackArray(Int_t i) const {return (i>=0&&i<4)?&fTracks[i]:0;}
5720c765	85	const TObjArray* GetPairArray(Int_t i) const {return (i>=0&&i<11)?
b2a297fa	86	static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i)):0;}
	87
	88	TObjArray** GetPairArraysPointer() { return &fPairCandidates; }
42c76bea	89	void SetPairArraysPointer( TObjArray *arr) { fPairCandidates=arr; }
620b34a5	90	void SetHistogramArray(AliDielectronHF * const histoarray) { fHistoArray=histoarray; }
620b34a5	91	const TObjArray * GetHistogramArray() const { return fHistoArray?fHistoArray->GetHistArray():0x0; }
d8bb1abe	92	const TObjArray * GetQAHistArray() const { return fQAmonitor?fQAmonitor->GetQAHistArray():0x0; }
620b34a5	93
b2a297fa	94	void SetHistogramManager(AliDielectronHistos * const histos) { fHistos=histos; }
c8f0f810	95	AliDielectronHistos* GetHistoManager() const { return fHistos; }
b2a297fa	96	const THashList * GetHistogramList() const { return fHistos?fHistos->GetHistogramList():0x0; }
	97
	98	Bool_t HasCandidates() const { return GetPairArray(1)?GetPairArray(1)->GetEntriesFast()>0:0; }
fb7d2d99	99	Bool_t HasCandidatesLikeSign() const {
	100	return (GetPairArray(0)&&GetPairArray(2)) ? (GetPairArray(0)->GetEntriesFast()>0 \|\| GetPairArray(2)->GetEntriesFast()>0) : 0;
	101	}
	102
5720c765	103	Bool_t HasCandidatesTR() const {return GetPairArray(10)?GetPairArray(10)->GetEntriesFast()>0:0;}
b2a297fa	104	void SetCFManagerPair(AliDielectronCF * const cf) { fCfManagerPair=cf; }
b2a297fa	105	AliDielectronCF* GetCFManagerPair() const { return fCfManagerPair; }
572b0139	106
5720c765	107	void SetPreFilterEventPlane(Bool_t setValue=kTRUE){fPreFilterEventPlane=setValue;};
5720c765	108	void SetLikeSignSubEvents(Bool_t setValue=kTRUE){fLikeSignSubEvents=setValue;};
554e40f8	109	void SetPreFilterUnlikeOnly(Bool_t setValue=kTRUE){fPreFilterUnlikeOnly=setValue;};
ba15fdfb	110	void SetPreFilterAllSigns(Bool_t setValue=kTRUE){fPreFilterAllSigns=setValue;};
554e40f8	111
2a14a7b1	112	void SetTrackRotator(AliDielectronTrackRotator * const rot) { fTrackRotator=rot; }
2a14a7b1	113	AliDielectronTrackRotator* GetTrackRotator() const { return fTrackRotator; }
fb7d2d99	114
5720c765	115	void SetMixingHandler(AliDielectronMixingHandler *mix) { fMixing=mix; }
	116	AliDielectronMixingHandler* GetMixingHandler() const { return fMixing; }
	117
fb7d2d99	118	void SetHasMC(Bool_t hasMC) { fHasMC = hasMC; }
fb7d2d99	119	Bool_t GetHasMC() const { return fHasMC; }
ba15fdfb	120
5720c765	121	void SetStoreRotatedPairs(Bool_t storeTR) {fStoreRotatedPairs = storeTR;}
2e02dba4	122	void SetDontClearArrays(Bool_t dontClearArrays=kTRUE) { fDontClearArrays=dontClearArrays; }
42c76bea	123	Bool_t DontClearArrays() const { return fDontClearArrays; }
5720c765	124
ba15fdfb	125	void AddSignalMC(AliDielectronSignalMC* signal);
ba15fdfb	126
572b0139	127	void SetDebugTree(AliDielectronDebugTree * const tree) { fDebugTree=tree; }
c8f0f810	128
c8f0f810	129	const TObjArray* GetMCSignals() const { return fSignalsMC; }
b2a297fa	130	static const char* TrackClassName(Int_t i) { return (i>=0&&i<4)?fgkTrackClassNames[i]:""; }
2a14a7b1	131	static const char* PairClassName(Int_t i) { return (i>=0&&i<11)?fgkPairClassNames[i]:""; }
572b0139	132
5720c765	133	void SetEstimatorFilename(const Char_t* filename) {fEstimatorFilename = filename;}
5720c765	134	void SetTRDcorrectionFilename(const Char_t* filename) {fTRDpidCorrectionFilename = filename;}
a823f01b	135	void SetVZEROCalibrationFilename(const Char_t* filename) {fVZEROCalibrationFilename = filename;}
a823f01b	136	void SetVZERORecenteringFilename(const Char_t* filename) {fVZERORecenteringFilename = filename;}
36a1e727	137	void SetZDCRecenteringFilename(const Char_t* filename) {fZDCRecenteringFilename = filename;}
0b369e55 JB	138	void InitLegEffMap(TString filename) { fLegEffMap=InitEffMap(filename) ;}
0b369e55 JB	139	void InitPairEffMap(TString filename) { fPairEffMap=InitEffMap(filename) ;}
36a1e727	140
30f9a393 JB	141	void SetCentroidCorrFunction(TF1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);
	142	void SetWidthCorrFunction(TF1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);
	143
572b0139	144	void SaveDebugTree();
42c76bea	145	Bool_t DoEventProcess() const { return fEventProcess; }
	146	void SetEventProcess(Bool_t setValue=kTRUE) { fEventProcess=setValue; }
	147	void FillHistogramsFromPairArray(Bool_t pairInfoOnly=kFALSE);
b2a297fa	148
5720c765	149	private:
d8bb1abe	150
	151	Bool_t fCutQA; // monitor cuts
	152	AliDielectronCutQA *fQAmonitor; // monitoring of cuts
9ad9e048	153	TH1 *fPostPIDCntrdCorr; // post pid correction object for centroids
9ad9e048	154	TH1 *fPostPIDWdthCorr; // post pid correction object for widths
7965afb6	155	THnBase *fLegEffMap; // single electron efficiency map
0b369e55	156	THnBase *fPairEffMap; // pair efficiency map
61d106d3	157	AliAnalysisFilter fEventFilter; // Event cuts
	158	AliAnalysisFilter fTrackFilter; // leg cuts
	159	AliAnalysisFilter fPairPreFilter; // pair prefilter cuts
	160	AliAnalysisFilter fPairPreFilterLegs; // Leg filter after the pair prefilter cuts
	161	AliAnalysisFilter fPairFilter; // pair cuts
5720c765	162	AliAnalysisFilter fEventPlanePreFilter; // event plane prefilter cuts
	163	AliAnalysisFilter fEventPlanePOIPreFilter; // PoI cuts in the event plane prefilter
	164
b2a297fa	165	Int_t fPdgMother; // pdg code of mother tracks
8df8e382	166	Int_t fPdgLeg1; // pdg code leg1
8df8e382	167	Int_t fPdgLeg2; // pdg code leg2
554e40f8	168
ba15fdfb	169	TObjArray* fSignalsMC; // array of AliDielectronSignalMC
ba15fdfb	170
554e40f8	171	Bool_t fNoPairing; // if to skip pairing, can be used for track QA only
5156b880	172	Bool_t fProcessLS; // do the like-sign pairing (default kTRUE)
08b801a6	173	Bool_t fUseKF; // if to skip pairing, can be used for track QA only
620b34a5	174
620b34a5	175	AliDielectronHF *fHistoArray; // Histogram framework
b2a297fa	176	AliDielectronHistos *fHistos; // Histogram manager
	177	// Streaming and merging should be handled
	178	// by the analysis framework
a94c2e7e	179	TBits *fUsedVars; // used variables
a94c2e7e	180
b2a297fa	181	TObjArray fTracks[4]; //! Selected track candidates
	182	// 0: Event1, positive particles
	183	// 1: Event1, negative particles
	184	// 2: Event2, positive particles
	185	// 3: Event2, negative particles
	186
	187	TObjArray *fPairCandidates; //! Pair candidate arrays
	188	//TODO: better way to store it? TClonesArray?
	189
	190	AliDielectronCF *fCfManagerPair;//Correction Framework Manager for the Pair
2a14a7b1	191	AliDielectronTrackRotator *fTrackRotator; //Track rotator
572b0139	192	AliDielectronDebugTree *fDebugTree; // Debug tree output
5720c765	193	AliDielectronMixingHandler *fMixing; // handler for event mixing
554e40f8	194
5720c765	195	Bool_t fPreFilterEventPlane; //Filter for the Eventplane determination in TPC
5720c765	196	Bool_t fLikeSignSubEvents; //Option for dividing into subevents, sub1 ++ sub2 --
554e40f8	197	Bool_t fPreFilterUnlikeOnly; //Apply PreFilter either in +- or to ++/--/+- individually
5720c765	198	Bool_t fPreFilterAllSigns; //Apply PreFilter find in ++/--/+- and remove from all
fb7d2d99	199	Bool_t fHasMC; //If we run with MC, at the moment only needed in AOD
2e02dba4	200	Bool_t fStoreRotatedPairs; //It the rotated pairs should be stored in the pair array
2e02dba4	201	Bool_t fDontClearArrays; //Don't clear the arrays at the end of the Process function, needed for external use of pair and tracks
42c76bea	202	Bool_t fEventProcess; //Process event (or pair array)
42c76bea	203
b2a297fa	204	void FillTrackArrays(AliVEvent * const ev, Int_t eventNr=0);
4533e78e	205	void EventPlanePreFilter(Int_t arr1, Int_t arr2, TObjArray arrTracks1, TObjArray arrTracks2, const AliVEvent *ev);
61d106d3	206	void PairPreFilter(Int_t arr1, Int_t arr2, TObjArray &arrTracks1, TObjArray &arrTracks2);
b2a297fa	207	void FillPairArrays(Int_t arr1, Int_t arr2);
2a14a7b1	208	void FillPairArrayTR();
b2a297fa	209
	210	Int_t GetPairIndex(Int_t arr1, Int_t arr2) const {return arr1>=arr2?arr1(arr1+1)/2+arr2:arr2(arr2+1)/2+arr1;}
	211
	212	void InitPairCandidateArrays();
	213	void ClearArrays();
	214
	215	TObjArray* PairArray(Int_t i);
0b369e55	216	THnBase* InitEffMap(TString filename);
b2a297fa	217
b2a297fa	218	static const char* fgkTrackClassNames[4]; //Names for track arrays
2a14a7b1	219	static const char* fgkPairClassNames[11]; //Names for pair arrays
b2a297fa	220
5720c765	221	TString fEstimatorFilename; // name for the pp multiplicity estimators filename
5720c765	222	TString fTRDpidCorrectionFilename; // name for the file containing the single particle TRD pid corrections
a823f01b	223	TString fVZEROCalibrationFilename; // file containing VZERO channel-by-channel calibration
a823f01b	224	TString fVZERORecenteringFilename; // file containing VZERO Q-vector recentering averages
36a1e727	225	TString fZDCRecenteringFilename; // file containing ZDCQ-vector recentering averages
5720c765	226
5720c765	227	void ProcessMC(AliVEvent *ev1);
b2a297fa	228
c315310a	229	void FillHistograms(const AliVEvent *ev, Bool_t pairInfoOnly=kFALSE);
f0351f9c	230	void FillMCHistograms(const AliVEvent *ev);
833da63d	231	void FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal);
5720c765	232	void FillHistogramsMC(const AliMCEvent ev, AliVEvent ev1);
ffbede40	233	void FillHistogramsPair(AliDielectronPair *pair,Bool_t fromPreFilter=kFALSE);
554e40f8	234	void FillHistogramsTracks(TObjArray **tracks);
554e40f8	235
572b0139	236	void FillDebugTree();
5720c765	237
b2a297fa	238	AliDielectron(const AliDielectron &c);
	239	AliDielectron &operator=(const AliDielectron &c);
	240
a94c2e7e	241	ClassDef(AliDielectron,12);
b2a297fa	242	};
	243
	244	inline void AliDielectron::InitPairCandidateArrays()
	245	{
	246	//
	247	// initialise all pair candidate arrays
	248	//
	249	fPairCandidates->SetOwner();
5720c765	250	for (Int_t i=0;i<11;++i){
b2a297fa	251	TObjArray *arr=new TObjArray;
	252	fPairCandidates->AddAt(arr,i);
	253	arr->SetOwner();
	254	}
	255	}
	256
	257	inline TObjArray* AliDielectron::PairArray(Int_t i)
	258	{
	259	//
	260	// for internal use only: unchecked return of track array for fast access
	261	//
	262	return static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i));
	263	}
	264
	265	inline void AliDielectron::ClearArrays()
	266	{
	267	//
	268	// Reset the Arrays
	269	//
	270	for (Int_t i=0;i<4;++i){
	271	fTracks[i].Clear();
	272	}
5720c765	273	for (Int_t i=0;i<11;++i){
5720c765	274	if (PairArray(i)) PairArray(i)->Delete();
b2a297fa	275	}
	276	}
	277
	278	#endif