[u/mrichter/AliRoot.git] / PWG3 / 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 <AliAnalysisFilter.h>
#include <AliKFParticle.h>

#include "AliDielectronHistos.h"
#include "AliDielectronPair.h"

class AliVEvent;
class THashList;
class AliDielectronCF;
class AliDielectronDebugTree;

//________________________________________________________________
class AliDielectron : public TNamed {
  
public:
  enum ParticleValues { kPx=0, kPy, kPz, kPt, kP, kXv, kYv, kZv, kOneOverPt,
      kPhi, kTheta, kE, kM, kEta, kY, kCharge, kNParticleValues };
  enum PairValues { kChi2NDF=kNParticleValues, kDecayLength, kR, kOpeningAngle, kMerr, kNPairValues };
  
  AliDielectron();
  AliDielectron(const char* name, const char* title);
  virtual ~AliDielectron();

  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;   }
  
  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(AliDielectronHistos * const histos) { fHistos=histos; }
  const THashList * GetHistogramList() const { return fHistos?fHistos->GetHistogramList():0x0; }

  Bool_t HasCandidates() const { return GetPairArray(1)?GetPairArray(1)->GetEntriesFast()>0:0; }

  void SetCFManagerPair(AliDielectronCF * const cf) { fCfManagerPair=cf; }
  AliDielectronCF* GetCFManagerPair() const { return fCfManagerPair; }

  void SetDebugTree(AliDielectronDebugTree * const tree) { fDebugTree=tree; }
  
  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<10)?fgkPairClassNames[i]:""; }

  void SaveDebugTree();
  
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
  
  AliDielectronHistos *fHistos;   // Histogram manager
                                  //  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

  AliDielectronDebugTree *fDebugTree;  // Debug tree output
  
  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);
  
  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[10];   //Names for pair arrays

  void ProcessMC();
  
  void  FillHistograms(const AliVEvent *ev);
  void  FillDebugTree();
  
  AliDielectron(const AliDielectron &c);
  AliDielectron &operator=(const AliDielectron &c);
  
  ClassDef(AliDielectron,4);
};

inline void AliDielectron::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* 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<10;++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>
	21
	22	#include <AliAnalysisFilter.h>
	23	#include <AliKFParticle.h>
	24
	25	#include "AliDielectronHistos.h"
	26	#include "AliDielectronPair.h"
	27
	28	class AliVEvent;
	29	class THashList;
	30	class AliDielectronCF;
572b0139	31	class AliDielectronDebugTree;
b2a297fa	32
	33	//________________________________________________________________
	34	class AliDielectron : public TNamed {
	35
	36	public:
	37	enum ParticleValues { kPx=0, kPy, kPz, kPt, kP, kXv, kYv, kZv, kOneOverPt,
	38	kPhi, kTheta, kE, kM, kEta, kY, kCharge, kNParticleValues };
	39	enum PairValues { kChi2NDF=kNParticleValues, kDecayLength, kR, kOpeningAngle, kMerr, kNPairValues };
	40
	41	AliDielectron();
	42	AliDielectron(const char* name, const char* title);
	43	virtual ~AliDielectron();
	44
	45	void Init();
	46
	47	void Process(AliVEvent ev1, AliVEvent ev2=0);
	48
b2a297fa	49	const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; }
	50	const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; }
	51	const AliAnalysisFilter& GetPairFilter() const { return fPairFilter; }
	52
61d106d3	53	AliAnalysisFilter& GetEventFilter() { return fEventFilter; }
	54	AliAnalysisFilter& GetTrackFilter() { return fTrackFilter; }
	55	AliAnalysisFilter& GetPairFilter() { return fPairFilter; }
	56	AliAnalysisFilter& GetPairPreFilter() { return fPairPreFilter; }
	57	AliAnalysisFilter& GetPairPreFilterLegs() { return fPairPreFilterLegs; }
	58
8df8e382	59	void SetMotherPdg( Int_t pdgMother ) { fPdgMother=pdgMother; }
	60	void SetLegPdg(Int_t pdgLeg1, Int_t pdgLeg2) { fPdgLeg1=pdgLeg1; fPdgLeg2=pdgLeg2; }
	61	Int_t GetMotherPdg() const { return fPdgMother; }
	62	Int_t GetLeg1Pdg() const { return fPdgLeg1; }
	63	Int_t GetLeg2Pdg() const { return fPdgLeg2; }
b2a297fa	64
	65	const TObjArray* GetTrackArray(Int_t i) const {return (i>=0&&i<4)?&fTracks[i]:0;}
	66	const TObjArray* GetPairArray(Int_t i) const {return (i>=0&&i<10)?
	67	static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i)):0;}
	68
	69	TObjArray** GetPairArraysPointer() { return &fPairCandidates; }
	70
	71	void SetHistogramManager(AliDielectronHistos * const histos) { fHistos=histos; }
	72	const THashList * GetHistogramList() const { return fHistos?fHistos->GetHistogramList():0x0; }
	73
	74	Bool_t HasCandidates() const { return GetPairArray(1)?GetPairArray(1)->GetEntriesFast()>0:0; }
	75
	76	void SetCFManagerPair(AliDielectronCF * const cf) { fCfManagerPair=cf; }
	77	AliDielectronCF* GetCFManagerPair() const { return fCfManagerPair; }
572b0139	78
572b0139	79	void SetDebugTree(AliDielectronDebugTree * const tree) { fDebugTree=tree; }
b2a297fa	80
	81	static const char* TrackClassName(Int_t i) { return (i>=0&&i<4)?fgkTrackClassNames[i]:""; }
	82	static const char* PairClassName(Int_t i) { return (i>=0&&i<10)?fgkPairClassNames[i]:""; }
572b0139	83
572b0139	84	void SaveDebugTree();
b2a297fa	85
	86	private:
	87
	88
61d106d3	89	AliAnalysisFilter fEventFilter; // Event cuts
	90	AliAnalysisFilter fTrackFilter; // leg cuts
	91	AliAnalysisFilter fPairPreFilter; // pair prefilter cuts
	92	AliAnalysisFilter fPairPreFilterLegs; // Leg filter after the pair prefilter cuts
	93	AliAnalysisFilter fPairFilter; // pair cuts
b2a297fa	94
b2a297fa	95	Int_t fPdgMother; // pdg code of mother tracks
8df8e382	96	Int_t fPdgLeg1; // pdg code leg1
8df8e382	97	Int_t fPdgLeg2; // pdg code leg2
b2a297fa	98
	99	AliDielectronHistos *fHistos; // Histogram manager
	100	// Streaming and merging should be handled
	101	// by the analysis framework
	102
	103	TObjArray fTracks[4]; //! Selected track candidates
	104	// 0: Event1, positive particles
	105	// 1: Event1, negative particles
	106	// 2: Event2, positive particles
	107	// 3: Event2, negative particles
	108
	109	TObjArray *fPairCandidates; //! Pair candidate arrays
	110	//TODO: better way to store it? TClonesArray?
	111
	112	AliDielectronCF *fCfManagerPair;//Correction Framework Manager for the Pair
	113
572b0139	114	AliDielectronDebugTree *fDebugTree; // Debug tree output
572b0139	115
b2a297fa	116	void FillTrackArrays(AliVEvent * const ev, Int_t eventNr=0);
61d106d3	117	void PairPreFilter(Int_t arr1, Int_t arr2, TObjArray &arrTracks1, TObjArray &arrTracks2);
b2a297fa	118	void FillPairArrays(Int_t arr1, Int_t arr2);
	119
	120	Int_t GetPairIndex(Int_t arr1, Int_t arr2) const {return arr1>=arr2?arr1(arr1+1)/2+arr2:arr2(arr2+1)/2+arr1;}
	121
	122	void InitPairCandidateArrays();
	123	void ClearArrays();
	124
	125	TObjArray* PairArray(Int_t i);
	126
	127	static const char* fgkTrackClassNames[4]; //Names for track arrays
	128	static const char* fgkPairClassNames[10]; //Names for pair arrays
	129
	130	void ProcessMC();
	131
a655b716	132	void FillHistograms(const AliVEvent *ev);
572b0139	133	void FillDebugTree();
a655b716	134
b2a297fa	135	AliDielectron(const AliDielectron &c);
	136	AliDielectron &operator=(const AliDielectron &c);
	137
61d106d3	138	ClassDef(AliDielectron,4);
b2a297fa	139	};
	140
	141	inline void AliDielectron::InitPairCandidateArrays()
	142	{
	143	//
	144	// initialise all pair candidate arrays
	145	//
	146	fPairCandidates->SetOwner();
	147	for (Int_t i=0;i<10;++i){
	148	TObjArray *arr=new TObjArray;
	149	fPairCandidates->AddAt(arr,i);
	150	arr->SetOwner();
	151	}
	152	}
	153
	154	inline TObjArray* AliDielectron::PairArray(Int_t i)
	155	{
	156	//
	157	// for internal use only: unchecked return of track array for fast access
	158	//
	159	return static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i));
	160	}
	161
	162	inline void AliDielectron::ClearArrays()
	163	{
	164	//
	165	// Reset the Arrays
	166	//
	167	for (Int_t i=0;i<4;++i){
	168	fTracks[i].Clear();
	169	}
	170	for (Int_t i=0;i<10;++i){
	171	PairArray(i)->Delete();
	172	}
	173	}
	174
	175	#endif