Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file source file inheritance tree (.pdf)

Sections: class description function members data members class charts

AliRoot » PWGCF » FEMTOSCOPY » ALIFEMTO » AliFemtoSimpleAnalysis

class AliFemtoSimpleAnalysis: public AliFemtoAnalysis


AliFemtoSimpleAnalysis - the most basic analysis there is. All other
inherit from this one. Provides basic functionality for the analysis.
To properly set up the analysis the following steps should be taken:

- create particle cuts and add them via SetFirstParticleCut and
SetSecondParticleCut. If one analyzes identical particle
correlations, the first particle cut must be also the second
particle cut.

- create pair cuts and add them via SetPairCut

- create one or many correlation functions and add them via
AddCorrFctn method.

- specify how many events are to be strored in the mixing buffer for
background construction

Then, when the analysis is run, for each event, the EventBegin is
called before any processing is done, then the ProcessEvent is called
which takes care of creating real and mixed pairs and sending them
 to all the registered correlation functions. At the end of each event,
after all pairs are processed, EventEnd is called. After the whole
analysis finishes (there is no more events to process) Finish() is
called.

Function Members (Methods)

public:

	AliFemtoSimpleAnalysis()
	AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& OriginalAnalysis)
virtual	~AliFemtoSimpleAnalysis()
void	AddCorrFctn(AliFemtoCorrFctn* cf)
bool	AnalyzeIdenticalParticles() const
virtual AliFemtoCorrFctn*	CorrFctn(int n)
AliFemtoCorrFctnCollection*	CorrFctnCollection()
AliFemtoPicoEvent*	CurrentPicoEvent()
virtual void	EventBegin(const AliFemtoEvent* TheEventToBegin)
virtual AliFemtoEventCut*	EventCut()
virtual void	EventEnd(const AliFemtoEvent* TheEventToWrapUp)
virtual void	Finish()
virtual AliFemtoParticleCut*	FirstParticleCut()
int	GetNeventsProcessed() const
virtual TList*	GetOutputList()
virtual TList*	ListSettings()
list<AliFemtoPicoEvent,allocator<AliFemtoPicoEvent> >*	MixingBuffer()
bool	MixingBufferFull()
unsigned int	NumEventsToMix() const
AliFemtoSimpleAnalysis&	operator=(const AliFemtoSimpleAnalysis& aAna)
virtual AliFemtoPairCut*	PairCut()
virtual void	ProcessEvent(const AliFemtoEvent* EventToProcess)
virtual AliFemtoString	Report()
virtual AliFemtoParticleCut*	SecondParticleCut()
void	SetEventCut(AliFemtoEventCut* x)
void	SetFirstParticleCut(AliFemtoParticleCut* x)
void	SetMinSizePartCollection(unsigned int minSize)
void	SetNumEventsToMix(const unsigned int& nmix)
void	SetPairCut(AliFemtoPairCut* x)
void	SetSecondParticleCut(AliFemtoParticleCut* x)
void	SetV0SharedDaughterCut(Bool_t aPerform)
void	SetVerboseMode(Bool_t aVerbose)
bool	V0SharedDaughterCut()

protected:

void	AddEventProcessed()
void	MakePairs(const char* type, AliFemtoParticleCollection* ParticlesPassingCut1, AliFemtoParticleCollection* ParticlesPssingCut2 = 0)

Data Members

protected:

AliFemtoCorrFctnCollection*	fCorrFctnCollection	correlation functions of this analysis
AliFemtoEventCut*	fEventCut	cut to select events
AliFemtoParticleCut*	fFirstParticleCut	select particles of type #1
unsigned int	fMinSizePartCollection	Don't use event if it has fewer than this many particles passing ParticleCuts default 0
list<AliFemtoPicoEvent,allocator<AliFemtoPicoEvent> >*	fMixingBuffer	mixing buffer used in this simplest analysis
unsigned int	fNeventsProcessed	How many events processed so far
unsigned int	fNumEventsToMix	How many "previous" events get mixed with this one, to make background
AliFemtoPairCut*	fPairCut	cut applied to pairs
Bool_t	fPerformSharedDaughterCut
AliFemtoPicoEvent*	fPicoEvent	! The current event, in the small (pico) form
AliFemtoPicoEventCollectionVectorHideAway*	fPicoEventCollectionVectorHideAway	! Mixing Buffer used for Analyses which wrap this one
AliFemtoParticleCut*	fSecondParticleCut	select particles of type #2
Bool_t	fVerbose

Class Charts

Inheritance Chart:

AliFemtoAnalysis

←

AliFemtoSimpleAnalysis

←

AliFemtoAnalysisAzimuthal

AliFemtoAnalysisAzimuthalPbPb

AliFemtoAnalysisReactionPlane

AliFemtoLikeSignAnalysis

AliFemtoVertexAnalysis

AliFemtoVertexMultAnalysis

Function documentation

AliFemtoSimpleAnalysis()

 Default constructor
  mControlSwitch     = 0;

AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& OriginalAnalysis)

 Copy constructor
AliFemtoSimpleAnalysis();

~AliFemtoSimpleAnalysis()

 destructor

AliFemtoSimpleAnalysis& operator=(const AliFemtoSimpleAnalysis& aAna)

 Assignment operator

AliFemtoCorrFctn* CorrFctn(int n)

 return pointer to n-th correlation function

AliFemtoString Report()

 Create a simple report from the analysis execution

void ProcessEvent(const AliFemtoEvent* EventToProcess)

 Add event to processed events

void MakePairs(const char* type, AliFemtoParticleCollection* ParticlesPassingCut1, AliFemtoParticleCollection* ParticlesPssingCut2 = 0)

 Build pairs, check pair cuts, and call CFs' AddRealPair() or
 AddMixedPair() methods. If no second particle collection is
 specfied, make pairs within first particle collection.

void EventBegin(const AliFemtoEvent* TheEventToBegin)

 Perform initialization operations at the beginning of the event processing
cout << " AliFemtoSimpleAnalysis::EventBegin(const AliFemtoEvent* ev) " << endl;

void EventEnd(const AliFemtoEvent* TheEventToWrapUp)

 Fiinsh operations at the end of event processing

void Finish()

 Perform finishing operations after all events are processed

void AddEventProcessed()

 Increase count of processed events

TList* ListSettings()

 Collect settings list

TList* GetOutputList()

 Collect the list of output objects
 to be written

AliFemtoPairCut* PairCut()

 Get's

{return fPairCut;}

AliFemtoEventCut* EventCut()

{return fEventCut;}

AliFemtoParticleCut* FirstParticleCut()

{return fFirstParticleCut;}

AliFemtoParticleCut* SecondParticleCut()

{return fSecondParticleCut;}

AliFemtoCorrFctnCollection* CorrFctnCollection()

{return fCorrFctnCollection;}

unsigned int NumEventsToMix() const

{return fNumEventsToMix;}

AliFemtoPicoEvent* CurrentPicoEvent()

{return fPicoEvent;}

AliFemtoPicoEventCollection* MixingBuffer()

{return fMixingBuffer;}

bool AnalyzeIdenticalParticles() const

{ return (fFirstParticleCut==fSecondParticleCut); }

bool V0SharedDaughterCut()

{ return fPerformSharedDaughterCut; }

void SetPairCut(AliFemtoPairCut* x)

 Set's

{ fPairCut = x; x->SetAnalysis((AliFemtoAnalysis*)this);}

void AddCorrFctn(AliFemtoCorrFctn* cf)

{fCorrFctnCollection->push_back(cf); cf->SetAnalysis((AliFemtoAnalysis*)this);}

void SetEventCut(AliFemtoEventCut* x)

{fEventCut = x; x->SetAnalysis((AliFemtoAnalysis*)this);}

void SetFirstParticleCut(AliFemtoParticleCut* x)

{fFirstParticleCut = x; x->SetAnalysis((AliFemtoAnalysis*)this);}

void SetSecondParticleCut(AliFemtoParticleCut* x)

{fSecondParticleCut = x; x->SetAnalysis((AliFemtoAnalysis*)this);}

void SetNumEventsToMix(const unsigned int& nmix)

{ fNumEventsToMix = nmix;}

bool MixingBufferFull()

{return (fMixingBuffer->size() >= fNumEventsToMix);}

int GetNeventsProcessed() const

{return fNeventsProcessed;}

void SetMinSizePartCollection(unsigned int minSize)

{fMinSizePartCollection = minSize;}

void SetVerboseMode(Bool_t aVerbose)

{fVerbose = aVerbose;}

void SetV0SharedDaughterCut(Bool_t aPerform)

{ fPerformSharedDaughterCut = aPerform; }