[u/mrichter/AliRoot.git] / HBTAN / AliHBTAnalysis.h

#ifndef ALIHBTANALYSIS_H
#define ALIHBTANALYSIS_H
//_________________________________________________________
////////////////////////////////////////////////////////////////////////////
//
// class AliHBTAnalysis
//
// Central Object Of HBTAnalyser: 
// This class performs main looping within HBT Analysis
// User must plug a reader of Type AliReader
// User plugs in coorelation and monitor functions
// as well as monitor functions
//
// HBT Analysis Tool, which is integral part of AliRoot,
// ALICE Off-Line framework:
//
// Piotr.Skowronski@cern.ch
// more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
//
////////////////////////////////////////////////////////////////////////////
//_________________________________________________________

#include <AliAnalysis.h>
#include "AliAODPairCut.h"
#include "AliAODParticleCut.h"

class AliHBTCut;
//class AliHBTPair;

class AliHBTRun;
class AliAOD;
class AliReader;
class AliHBTOnePairFctn;      
class AliHBTTwoPairFctn;

class AliHBTMonOneParticleFctn;
class AliHBTMonTwoParticleFctn;

class TList;

class AliHBTAnalysis: public AliAnalysis
 {
   public:
     AliHBTAnalysis();
     AliHBTAnalysis(const AliHBTAnalysis& in);
     AliHBTAnalysis& operator=(const AliHBTAnalysis& /*right*/);
     virtual ~AliHBTAnalysis();

     Int_t  Init();
     Int_t ProcessEvent(AliAOD* aodrec, AliAOD* aodsim = 0x0);
     Int_t Finish();
     
     virtual void Process(Option_t* option = "TracksAndParticles");
     
     void SetGlobalPairCut(AliAODPairCut* cut);
     
     void AddTrackFunction(AliHBTOnePairFctn* f);
     void AddParticleFunction(AliHBTOnePairFctn* f);
     void AddParticleAndTrackFunction(AliHBTTwoPairFctn* f);
     
     void AddParticleMonitorFunction(AliHBTMonOneParticleFctn* f);    //z.ch.
     void AddTrackMonitorFunction(AliHBTMonOneParticleFctn* f);    //z.ch.
     void AddParticleAndTrackMonitorFunction(AliHBTMonTwoParticleFctn* f);//z.ch.

     void AddResolutionFunction(AliHBTTwoPairFctn* f){AddParticleAndTrackFunction(f);}
     
     void SetReader(AliReader* r){fReader = r;}
     
     void WriteFunctions();
     
     void SetBufferSize(Int_t buffsize){fBufferSize=buffsize;}
     void SetOwner(Bool_t owner=kTRUE){fIsOwner=owner;}
     Bool_t IsOwner() const {return fIsOwner;}
     Bool_t IsNonIdentAnalysis();
     void   ResetFunctions();
     void   SetDisplayInfo(Int_t howoften){fDisplayMixingInfo = howoften;}//defines every each line info about mixing is displayed
     
     void   SetCutsOnParticles(); // -- aplies only to Process Tracks And Particles
     void   SetCutsOnTracks();// -- aplies only to Process Tracks And Particles
     void   SetCutsOnTracksAndParticles();// Default // -- aplies only to Process Tracks And Particles
     
     static void PressAnyKey();//small utility function that helps to make comfortable macros
   protected:
     
     Bool_t RunCoherencyCheck();
     
     void FilterOut(AliAOD* outpart1, AliAOD* outpart2, AliAOD* inpart,
                    AliAOD* outtrack1, AliAOD* outtrack2, AliAOD* intrack)const;
     void FilterOut(AliAOD* out1, AliAOD* out2, AliAOD* in)const;
     void DeleteFunctions();
     
     virtual void ProcessTracks();
     virtual void ProcessParticles();
     virtual void ProcessTracksAndParticles();
     
     virtual void ProcessTracksAndParticlesNonIdentAnal();
     virtual void ProcessParticlesNonIdentAnal();
     virtual void ProcessTracksNonIdentAnal();

     AliReader* fReader;//! Pointer to reader
     
     UInt_t fNTrackFunctions; //! Number of Tracks functions 
     UInt_t fNParticleFunctions; //! Number of particles functions
     UInt_t fNParticleAndTrackFunctions; //! Number of resolution functions
		
     UInt_t fNTrackMonitorFunctions; //! Number of Track Monitor functions 
     UInt_t fNParticleMonitorFunctions; //! Number of Particles Monitor functions 
     UInt_t fNParticleAndTrackMonitorFunctions; //! Number of Resolution Monitor functions 

     AliHBTOnePairFctn**  fTrackFunctions; //!array of pointers to functions that analyze rekonstructed tracks
     AliHBTOnePairFctn**  fParticleFunctions; //!array of pointers to functions that analyze generated particles
     AliHBTTwoPairFctn**  fParticleAndTrackFunctions; //!array of pointers to functions that analyze both 
                                        //reconstructed tracks and generated particles
		//i.e. - resolution analyzers
     AliHBTMonOneParticleFctn**  fParticleMonitorFunctions; //! array of pointers to monitoring functions
     AliHBTMonOneParticleFctn**  fTrackMonitorFunctions; //! which are used for single particle analysis,
     AliHBTMonTwoParticleFctn**  fParticleAndTrackMonitorFunctions;  //! cut monitoring, etc.


     /**********************************************/
     /* Control parameters  */
     /**********************************************/

     AliAODPairCut*   fPairCut;//! Pair cut applied for all mixed particles
      
     Int_t  fBufferSize; //!defines the size of buffer for mixed events; -1==MIX All
     Int_t  fDisplayMixingInfo;//!defines every which particle mixing info is displayed
     Bool_t fIsOwner;//!defines of all functions are supposed to be deleted while by the way of analysis defaulr false

   private:
     Bool_t (AliHBTAnalysis::*fkPass)(AliAODPair* partpair, AliAODPair* trackpair) const;//Pointer to function that performes pair cut
     Bool_t (AliHBTAnalysis::*fkPass1)(AliVAODParticle* partpair, AliVAODParticle* trackpair) const;//Pointer to function that performes cut on first particle
     Bool_t (AliHBTAnalysis::*fkPass2)(AliVAODParticle* partpair, AliVAODParticle* trackpair) const;//Pointer to function that performes cut on second particle
     Bool_t (AliHBTAnalysis::*fkPassPairProp)(AliAODPair* partpair, AliAODPair* trackpair) const;//Pointer to function that performes pair cut
     
     Bool_t PassPartAndTrack (AliAODPair* partpair, AliAODPair* trackpair) const {return (fPairCut->Pass((AliAODPair*)partpair))?kTRUE:fPairCut->Pass((AliAODPair*)trackpair);}
     Bool_t PassPartAndTrack1(AliVAODParticle* part, AliVAODParticle* track) const;
     Bool_t PassPartAndTrack2(AliVAODParticle* part, AliVAODParticle* track) const;
     Bool_t PassPairPropPartAndTrack (AliAODPair* partpair, AliAODPair* trackpair) const {return (fPairCut->PassPairProp((AliAODPair*)partpair))?kTRUE:fPairCut->PassPairProp((AliAODPair*)trackpair);}
     
     Bool_t PassPart (AliAODPair* partpair, AliAODPair* /*trackpair*/) const {return fPairCut->Pass((AliAODPair*)partpair);}
     Bool_t PassPart1(AliVAODParticle* part, AliVAODParticle* /*track*/) const {return fPairCut->GetFirstPartCut()->Pass(part);}
     Bool_t PassPart2(AliVAODParticle* part, AliVAODParticle* /*track*/) const {return fPairCut->GetSecondPartCut()->Pass(part);}
     Bool_t PassPairPropPart (AliAODPair* partpair, AliAODPair* /*trackpair*/) const {return fPairCut->PassPairProp((AliAODPair*)partpair);}
     
     Bool_t PassTrack (AliAODPair* /*partpair*/, AliAODPair* trackpair) const {return fPairCut->Pass((AliAODPair*)trackpair);}
     Bool_t PassTrack1(AliVAODParticle* /*part*/, AliVAODParticle* track) const {return fPairCut->GetFirstPartCut()->Pass(track);}
     Bool_t PassTrack2(AliVAODParticle* /*part*/, AliVAODParticle* track) const {return fPairCut->GetSecondPartCut()->Pass(track);}
     Bool_t PassPairPropTrack (AliAODPair* /*partpair*/, AliAODPair* trackpair) const {return fPairCut->PassPairProp((AliAODPair*)trackpair);}

     static const UInt_t fgkFctnArraySize;//!
     static const UInt_t fgkDefaultMixingInfo;//!
     static const Int_t  fgkDefaultBufferSize;//!

     ClassDef(AliHBTAnalysis,0)
 };
 
inline Bool_t AliHBTAnalysis::PassPartAndTrack1(AliVAODParticle* part,AliVAODParticle* track) const
{
//Checks first particle from both, particle and track pairs
  AliAODParticleCut* pc = fPairCut->GetFirstPartCut();
  return (pc->Pass(part))?kTRUE:pc->Pass(track);
}
/*************************************************************************************/ 
inline Bool_t AliHBTAnalysis::PassPartAndTrack2(AliVAODParticle* part,AliVAODParticle* track) const
{
//Checks second particle from both, particle and track pairs
  AliAODParticleCut* pc = fPairCut->GetSecondPartCut();
  return (pc->Pass(part))?kTRUE:pc->Pass(track);
}
/*************************************************************************************/ 
 
#endif
Commit	Line	Data
	1	#ifndef ALIHBTANALYSIS_H
	2	#define ALIHBTANALYSIS_H
	3	//_________________________________________________________
	4	////////////////////////////////////////////////////////////////////////////
	5	//
	6	// class AliHBTAnalysis
	7	//
	8	// Central Object Of HBTAnalyser:
	9	// This class performs main looping within HBT Analysis
	10	// User must plug a reader of Type AliReader
	11	// User plugs in coorelation and monitor functions
	12	// as well as monitor functions
	13	//
	14	// HBT Analysis Tool, which is integral part of AliRoot,
	15	// ALICE Off-Line framework:
	16	//
	17	// Piotr.Skowronski@cern.ch
	18	// more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
	19	//
	20	////////////////////////////////////////////////////////////////////////////
	21	//_________________________________________________________
	22
	23	#include <AliAnalysis.h>
	24	#include "AliAODPairCut.h"
	25	#include "AliAODParticleCut.h"
	26
	27	class AliHBTCut;
	28	//class AliHBTPair;
	29
	30	class AliHBTRun;
	31	class AliAOD;
	32	class AliReader;
	33	class AliHBTOnePairFctn;
	34	class AliHBTTwoPairFctn;
	35
	36	class AliHBTMonOneParticleFctn;
	37	class AliHBTMonTwoParticleFctn;
	38
	39	class TList;
	40
	41	class AliHBTAnalysis: public AliAnalysis
	42	{
	43	public:
	44	AliHBTAnalysis();
	45	AliHBTAnalysis(const AliHBTAnalysis& in);
	46	AliHBTAnalysis& operator=(const AliHBTAnalysis& /right/);
	47	virtual ~AliHBTAnalysis();
	48
	49	Int_t Init();
	50	Int_t ProcessEvent(AliAOD* aodrec, AliAOD* aodsim = 0x0);
	51	Int_t Finish();
	52
	53	virtual void Process(Option_t* option = "TracksAndParticles");
	54
	55	void SetGlobalPairCut(AliAODPairCut* cut);
	56
	57	void AddTrackFunction(AliHBTOnePairFctn* f);
	58	void AddParticleFunction(AliHBTOnePairFctn* f);
	59	void AddParticleAndTrackFunction(AliHBTTwoPairFctn* f);
	60
	61	void AddParticleMonitorFunction(AliHBTMonOneParticleFctn* f); //z.ch.
	62	void AddTrackMonitorFunction(AliHBTMonOneParticleFctn* f); //z.ch.
	63	void AddParticleAndTrackMonitorFunction(AliHBTMonTwoParticleFctn* f);//z.ch.
	64
	65	void AddResolutionFunction(AliHBTTwoPairFctn* f){AddParticleAndTrackFunction(f);}
	66
	67	void SetReader(AliReader* r){fReader = r;}
	68
	69	void WriteFunctions();
	70
	71	void SetBufferSize(Int_t buffsize){fBufferSize=buffsize;}
	72	void SetOwner(Bool_t owner=kTRUE){fIsOwner=owner;}
	73	Bool_t IsOwner() const {return fIsOwner;}
	74	Bool_t IsNonIdentAnalysis();
	75	void ResetFunctions();
	76	void SetDisplayInfo(Int_t howoften){fDisplayMixingInfo = howoften;}//defines every each line info about mixing is displayed
	77
	78	void SetCutsOnParticles(); // -- aplies only to Process Tracks And Particles
	79	void SetCutsOnTracks();// -- aplies only to Process Tracks And Particles
	80	void SetCutsOnTracksAndParticles();// Default // -- aplies only to Process Tracks And Particles
	81
	82	static void PressAnyKey();//small utility function that helps to make comfortable macros
	83	protected:
	84
	85	Bool_t RunCoherencyCheck();
	86
	87	void FilterOut(AliAOD* outpart1, AliAOD* outpart2, AliAOD* inpart,
	88	AliAOD* outtrack1, AliAOD* outtrack2, AliAOD* intrack)const;
	89	void FilterOut(AliAOD* out1, AliAOD* out2, AliAOD* in)const;
	90	void DeleteFunctions();
	91
	92	virtual void ProcessTracks();
	93	virtual void ProcessParticles();
	94	virtual void ProcessTracksAndParticles();
	95
	96	virtual void ProcessTracksAndParticlesNonIdentAnal();
	97	virtual void ProcessParticlesNonIdentAnal();
	98	virtual void ProcessTracksNonIdentAnal();
	99
	100	AliReader* fReader;//! Pointer to reader
	101
	102	UInt_t fNTrackFunctions; //! Number of Tracks functions
	103	UInt_t fNParticleFunctions; //! Number of particles functions
	104	UInt_t fNParticleAndTrackFunctions; //! Number of resolution functions
	105
	106	UInt_t fNTrackMonitorFunctions; //! Number of Track Monitor functions
	107	UInt_t fNParticleMonitorFunctions; //! Number of Particles Monitor functions
	108	UInt_t fNParticleAndTrackMonitorFunctions; //! Number of Resolution Monitor functions
	109
	110	AliHBTOnePairFctn** fTrackFunctions; //!array of pointers to functions that analyze rekonstructed tracks
	111	AliHBTOnePairFctn** fParticleFunctions; //!array of pointers to functions that analyze generated particles
	112	AliHBTTwoPairFctn** fParticleAndTrackFunctions; //!array of pointers to functions that analyze both
	113	//reconstructed tracks and generated particles
	114	//i.e. - resolution analyzers
	115	AliHBTMonOneParticleFctn** fParticleMonitorFunctions; //! array of pointers to monitoring functions
	116	AliHBTMonOneParticleFctn** fTrackMonitorFunctions; //! which are used for single particle analysis,
	117	AliHBTMonTwoParticleFctn** fParticleAndTrackMonitorFunctions; //! cut monitoring, etc.
	118
	119
	120	/**********************************************/
	121	/* Control parameters */
	122	/**********************************************/
	123
	124	AliAODPairCut* fPairCut;//! Pair cut applied for all mixed particles
	125
	126	Int_t fBufferSize; //!defines the size of buffer for mixed events; -1==MIX All
	127	Int_t fDisplayMixingInfo;//!defines every which particle mixing info is displayed
	128	Bool_t fIsOwner;//!defines of all functions are supposed to be deleted while by the way of analysis defaulr false
	129
	130	private:
	131	Bool_t (AliHBTAnalysis::fkPass)(AliAODPair partpair, AliAODPair* trackpair) const;//Pointer to function that performes pair cut
	132	Bool_t (AliHBTAnalysis::fkPass1)(AliVAODParticle partpair, AliVAODParticle* trackpair) const;//Pointer to function that performes cut on first particle
	133	Bool_t (AliHBTAnalysis::fkPass2)(AliVAODParticle partpair, AliVAODParticle* trackpair) const;//Pointer to function that performes cut on second particle
	134	Bool_t (AliHBTAnalysis::fkPassPairProp)(AliAODPair partpair, AliAODPair* trackpair) const;//Pointer to function that performes pair cut
	135
	136	Bool_t PassPartAndTrack (AliAODPair* partpair, AliAODPair* trackpair) const {return (fPairCut->Pass((AliAODPair)partpair))?kTRUE:fPairCut->Pass((AliAODPair)trackpair);}
	137	Bool_t PassPartAndTrack1(AliVAODParticle* part, AliVAODParticle* track) const;
	138	Bool_t PassPartAndTrack2(AliVAODParticle* part, AliVAODParticle* track) const;
	139	Bool_t PassPairPropPartAndTrack (AliAODPair* partpair, AliAODPair* trackpair) const {return (fPairCut->PassPairProp((AliAODPair)partpair))?kTRUE:fPairCut->PassPairProp((AliAODPair)trackpair);}
	140
	141	Bool_t PassPart (AliAODPair* partpair, AliAODPair* /trackpair/) const {return fPairCut->Pass((AliAODPair*)partpair);}
	142	Bool_t PassPart1(AliVAODParticle* part, AliVAODParticle* /track/) const {return fPairCut->GetFirstPartCut()->Pass(part);}
	143	Bool_t PassPart2(AliVAODParticle* part, AliVAODParticle* /track/) const {return fPairCut->GetSecondPartCut()->Pass(part);}
	144	Bool_t PassPairPropPart (AliAODPair* partpair, AliAODPair* /trackpair/) const {return fPairCut->PassPairProp((AliAODPair*)partpair);}
	145
	146	Bool_t PassTrack (AliAODPair* /partpair/, AliAODPair* trackpair) const {return fPairCut->Pass((AliAODPair*)trackpair);}
	147	Bool_t PassTrack1(AliVAODParticle* /part/, AliVAODParticle* track) const {return fPairCut->GetFirstPartCut()->Pass(track);}
	148	Bool_t PassTrack2(AliVAODParticle* /part/, AliVAODParticle* track) const {return fPairCut->GetSecondPartCut()->Pass(track);}
	149	Bool_t PassPairPropTrack (AliAODPair* /partpair/, AliAODPair* trackpair) const {return fPairCut->PassPairProp((AliAODPair*)trackpair);}
	150
	151	static const UInt_t fgkFctnArraySize;//!
	152	static const UInt_t fgkDefaultMixingInfo;//!
	153	static const Int_t fgkDefaultBufferSize;//!
	154
	155	ClassDef(AliHBTAnalysis,0)
	156	};
	157
	158	inline Bool_t AliHBTAnalysis::PassPartAndTrack1(AliVAODParticle* part,AliVAODParticle* track) const
	159	{
	160	//Checks first particle from both, particle and track pairs
	161	AliAODParticleCut* pc = fPairCut->GetFirstPartCut();
	162	return (pc->Pass(part))?kTRUE:pc->Pass(track);
	163	}
	164	/*************************************************************************************/
	165	inline Bool_t AliHBTAnalysis::PassPartAndTrack2(AliVAODParticle* part,AliVAODParticle* track) const
	166	{
	167	//Checks second particle from both, particle and track pairs
	168	AliAODParticleCut* pc = fPairCut->GetSecondPartCut();
	169	return (pc->Pass(part))?kTRUE:pc->Pass(track);
	170	}
	171	/*************************************************************************************/
	172
	173	#endif