added initialization of AliFemtoSimpleAnalysis::fPerformSharedDaughterCut (coverity...
[u/mrichter/AliRoot.git] / PWGCF / FEMTOSCOPY / AliFemto / AliFemtoSimpleAnalysis.cxx
1 ///////////////////////////////////////////////////////////////////////////
2 //                                                                       //
3 // AliFemtoSimpleAnalysis - the most basic analysis there is. All other  //
4 // inherit from this one. Provides basic functionality for the analysis. //
5 // To properly set up the analysis the following steps should be taken:  //
6 //                                                                       //
7 // - create particle cuts and add them via SetFirstParticleCut and       //
8 //   SetSecondParticleCut. If one analyzes identical particle            //
9 //   correlations, the first particle cut must be also the second        //
10 //   particle cut.                                                       //
11 //                                                                       //
12 // - create pair cuts and add them via SetPairCut                        //
13 //                                                                       //
14 // - create one or many correlation functions and add them via           //
15 //   AddCorrFctn method.                                                 //
16 //                                                                       //
17 // - specify how many events are to be strored in the mixing buffer for  //
18 //   background construction                                             //
19 //                                                                       //
20 // Then, when the analysis is run, for each event, the EventBegin is     //
21 // called before any processing is done, then the ProcessEvent is called //
22 // which takes care of creating real and mixed pairs and sending them    //
23 // to all the registered correlation functions. At the end of each event,//
24 // after all pairs are processed, EventEnd is called. After the whole    //
25 // analysis finishes (there is no more events to process) Finish() is    //
26 // called.                                                               //
27 //                                                                       //
28 ///////////////////////////////////////////////////////////////////////////
29
30 #include "AliFemtoSimpleAnalysis.h"
31 #include "AliFemtoTrackCut.h"
32 #include "AliFemtoV0Cut.h"
33 #include "AliFemtoKinkCut.h"
34 #include <string>
35 #include <iostream>
36
37 // blah blah
38
39 #ifdef __ROOT__
40 ClassImp(AliFemtoSimpleAnalysis)
41 #endif
42
43 AliFemtoEventCut*    copyTheCut(AliFemtoEventCut*);
44 AliFemtoParticleCut* copyTheCut(AliFemtoParticleCut*);
45 AliFemtoPairCut*     copyTheCut(AliFemtoPairCut*);
46 AliFemtoCorrFctn*    copyTheCorrFctn(AliFemtoCorrFctn*);
47
48 // this little function used to apply ParticleCuts (TrackCuts or V0Cuts) and fill ParticleCollections of picoEvent
49 //  it is called from AliFemtoSimpleAnalysis::ProcessEvent()
50 void FillHbtParticleCollection(AliFemtoParticleCut*         partCut,
51                                AliFemtoEvent*               hbtEvent,
52                                AliFemtoParticleCollection*  partCollection,
53                                bool performSharedDaughterCut=kFALSE)
54 {
55   // Fill particle collections from the event
56   // by the particles that pass all the cuts
57   switch (partCut->Type()) {
58   case hbtTrack:       // cut is cutting on Tracks
59   {
60     AliFemtoTrackCut* pCut = (AliFemtoTrackCut*) partCut;
61     AliFemtoTrack* pParticle;
62     AliFemtoTrackIterator pIter;
63     AliFemtoTrackIterator startLoop = hbtEvent->TrackCollection()->begin();
64     AliFemtoTrackIterator endLoop   = hbtEvent->TrackCollection()->end();
65     for (pIter=startLoop;pIter!=endLoop;pIter++){
66       pParticle = *pIter;
67       bool tmpPassParticle = pCut->Pass(pParticle);
68       pCut->FillCutMonitor(pParticle, tmpPassParticle);
69       if (tmpPassParticle){
70         AliFemtoParticle* particle = new AliFemtoParticle(pParticle,pCut->Mass());
71         partCollection->push_back(particle);
72       }
73     }
74     break;
75   }
76   case hbtV0:          // cut is cutting on V0s
77     {
78       AliFemtoV0Cut* pCut = (AliFemtoV0Cut*) partCut;
79       AliFemtoV0* pParticle;
80       AliFemtoV0Iterator pIter;
81
82       if(performSharedDaughterCut) {
83         AliFemtoV0Collection V0CorrectedCollection;
84         AliFemtoV0SharedDaughterCut sharedDaughterCut;
85         V0CorrectedCollection = sharedDaughterCut.AliFemtoV0SharedDaughterCutCollection(hbtEvent->V0Collection(), pCut);
86
87         AliFemtoV0Iterator startLoop = V0CorrectedCollection.begin();
88         AliFemtoV0Iterator endLoop   = V0CorrectedCollection.end();
89
90         for (pIter=startLoop;pIter!=endLoop;pIter++){
91           pParticle = *pIter;
92           AliFemtoParticle* particle = new AliFemtoParticle(pParticle,partCut->Mass());
93           partCollection->push_back(particle);
94         }
95       }
96       else { //previous, untouched loop:
97         AliFemtoV0Iterator startLoop = hbtEvent->V0Collection()->begin();
98         AliFemtoV0Iterator endLoop   = hbtEvent->V0Collection()->end();
99         for (pIter=startLoop;pIter!=endLoop;pIter++){
100           pParticle = *pIter;
101           bool tmpPassV0 = pCut->Pass(pParticle);
102           pCut->FillCutMonitor(pParticle,tmpPassV0);
103           if(tmpPassV0) {
104             AliFemtoParticle* particle = new AliFemtoParticle(pParticle,partCut->Mass());
105             partCollection->push_back(particle);
106           }
107         }
108       }
109
110       pCut->FillCutMonitor(hbtEvent,partCollection);// Gael 19/06/02
111
112       break;
113     }
114   case hbtKink:          // cut is cutting on Kinks  -- mal 25May2001
115     {
116       AliFemtoKinkCut* pCut = (AliFemtoKinkCut*) partCut;
117       AliFemtoKink* pParticle;
118       AliFemtoKinkIterator pIter;
119       AliFemtoKinkIterator startLoop = hbtEvent->KinkCollection()->begin();
120       AliFemtoKinkIterator endLoop   = hbtEvent->KinkCollection()->end();
121       // this following "for" loop is identical to the one above, but because of scoping, I can's see how to avoid repitition...
122       for (pIter=startLoop;pIter!=endLoop;pIter++){
123         pParticle = *pIter;
124         bool tmpPass = pCut->Pass(pParticle);
125         pCut->FillCutMonitor(pParticle,tmpPass);
126         if (tmpPass){
127           AliFemtoParticle* particle = new AliFemtoParticle(pParticle,partCut->Mass());
128           partCollection->push_back(particle);
129         }
130       }
131       break;
132     }
133   default:
134     cout << "FillHbtParticleCollection function (in AliFemtoSimpleAnalysis.cxx) - undefined Particle Cut type!!! \n";
135   }
136 }
137 //____________________________
138 AliFemtoSimpleAnalysis::AliFemtoSimpleAnalysis() :
139   fPicoEventCollectionVectorHideAway(0),
140   fPairCut(0),
141   fCorrFctnCollection(0),
142   fEventCut(0),
143   fFirstParticleCut(0),
144   fSecondParticleCut(0),
145   fMixingBuffer(0),
146   fPicoEvent(0),
147   fNumEventsToMix(0),
148   fNeventsProcessed(0),
149   fMinSizePartCollection(0),
150   fVerbose(kTRUE),
151   fPerformSharedDaughterCut(kFALSE)
152 {
153   // Default constructor
154   //  mControlSwitch     = 0;
155   fCorrFctnCollection = new AliFemtoCorrFctnCollection;
156   fMixingBuffer = new AliFemtoPicoEventCollection;
157 }
158 //____________________________
159
160 AliFemtoSimpleAnalysis::AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& a) :
161   AliFemtoAnalysis(),
162   fPicoEventCollectionVectorHideAway(0),
163   fPairCut(0),
164   fCorrFctnCollection(0),
165   fEventCut(0),
166   fFirstParticleCut(0),
167   fSecondParticleCut(0),
168   fMixingBuffer(0),
169   fPicoEvent(0),
170   fNumEventsToMix(0),
171   fNeventsProcessed(0),
172   fMinSizePartCollection(0),
173   fVerbose(kTRUE),
174   fPerformSharedDaughterCut(kFALSE)
175 {
176   // Copy constructor
177   //AliFemtoSimpleAnalysis();
178   fCorrFctnCollection = new AliFemtoCorrFctnCollection;
179   fMixingBuffer = new AliFemtoPicoEventCollection;
180
181   // find the right event cut
182   fEventCut = a.fEventCut->Clone();
183   // find the right first particle cut
184   fFirstParticleCut = a.fFirstParticleCut->Clone();
185   // find the right second particle cut
186   if (a.fFirstParticleCut==a.fSecondParticleCut)
187     SetSecondParticleCut(fFirstParticleCut); // identical particle hbt
188   else
189   fSecondParticleCut = a.fSecondParticleCut->Clone();
190
191   fPairCut = a.fPairCut->Clone();
192
193   if ( fEventCut ) {
194       SetEventCut(fEventCut); // this will set the myAnalysis pointer inside the cut
195       cout << " AliFemtoSimpleAnalysis::AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& a) - event cut set " << endl;
196   }
197   if ( fFirstParticleCut ) {
198       SetFirstParticleCut(fFirstParticleCut); // this will set the myAnalysis pointer inside the cut
199       cout << " AliFemtoSimpleAnalysis::AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& a) - first particle cut set " << endl;
200   }
201   if ( fSecondParticleCut ) {
202       SetSecondParticleCut(fSecondParticleCut); // this will set the myAnalysis pointer inside the cut
203       cout << " AliFemtoSimpleAnalysis::AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& a) - second particle cut set " << endl;
204   }  if ( fPairCut ) {
205       SetPairCut(fPairCut); // this will set the myAnalysis pointer inside the cut
206       cout << " AliFemtoSimpleAnalysis::AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& a) - pair cut set " << endl;
207   }
208
209   AliFemtoCorrFctnIterator iter;
210   for (iter=a.fCorrFctnCollection->begin(); iter!=a.fCorrFctnCollection->end();iter++){
211     cout << " AliFemtoSimpleAnalysis::AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& a) - looking for correlation functions " << endl;
212     AliFemtoCorrFctn* fctn = (*iter)->Clone();
213     if (fctn) AddCorrFctn(fctn);
214     else cout << " AliFemtoSimpleAnalysis::AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& a) - correlation function not found " << endl;
215   }
216
217   fNumEventsToMix = a.fNumEventsToMix;
218
219   fMinSizePartCollection = a.fMinSizePartCollection;  // minimum # particles in ParticleCollection
220
221   cout << " AliFemtoSimpleAnalysis::AliFemtoSimpleAnalysis(const AliFemtoSimpleAnalysis& a) - analysis copied " << endl;
222
223 }
224 //____________________________
225 AliFemtoSimpleAnalysis::~AliFemtoSimpleAnalysis(){
226   // destructor
227   cout << " AliFemtoSimpleAnalysis::~AliFemtoSimpleAnalysis()" << endl;
228   if (fEventCut) delete fEventCut; fEventCut=0;
229   if (fFirstParticleCut == fSecondParticleCut) fSecondParticleCut=0;
230   if (fFirstParticleCut)  delete fFirstParticleCut; fFirstParticleCut=0;
231   if (fSecondParticleCut) delete fSecondParticleCut; fSecondParticleCut=0;
232   if (fPairCut) delete fPairCut; fPairCut=0;
233   // now delete every CorrFunction in the Collection, and then the Collection itself
234   AliFemtoCorrFctnIterator iter;
235   for (iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
236     delete *iter;
237   }
238   delete fCorrFctnCollection;
239   // now delete every PicoEvent in the EventMixingBuffer and then the Buffer itself
240   if (fMixingBuffer) {
241     AliFemtoPicoEventIterator piter;
242     for (piter=fMixingBuffer->begin();piter!=fMixingBuffer->end();piter++){
243       delete *piter;
244     }
245     delete fMixingBuffer;
246   }
247 }
248 //______________________
249 AliFemtoSimpleAnalysis& AliFemtoSimpleAnalysis::operator=(const AliFemtoSimpleAnalysis& aAna)
250 {
251   // Assignment operator
252   if (this == &aAna)
253     return *this;
254
255   if (fCorrFctnCollection) delete fCorrFctnCollection;
256   fCorrFctnCollection = new AliFemtoCorrFctnCollection;
257   if (fMixingBuffer) delete fMixingBuffer;
258   fMixingBuffer = new AliFemtoPicoEventCollection;
259
260   // find the right event cut
261   if (fEventCut) delete fEventCut;
262   fEventCut = aAna.fEventCut->Clone();
263   // find the right first particle cut
264   if (fFirstParticleCut) delete fFirstParticleCut;
265   fFirstParticleCut = aAna.fFirstParticleCut->Clone();
266   // find the right second particle cut
267   if (fSecondParticleCut) delete fSecondParticleCut;
268   if (aAna.fFirstParticleCut==aAna.fSecondParticleCut)
269     SetSecondParticleCut(fFirstParticleCut); // identical particle hbt
270   else
271     fSecondParticleCut = aAna.fSecondParticleCut->Clone();
272
273   if (fPairCut) delete fPairCut;
274   fPairCut = aAna.fPairCut->Clone();
275
276   if ( fEventCut ) {
277     SetEventCut(fEventCut); // this will set the myAnalysis pointer inside the cut
278   }
279   if ( fFirstParticleCut ) {
280     SetFirstParticleCut(fFirstParticleCut); // this will set the myAnalysis pointer inside the cut
281   }
282   if ( fSecondParticleCut ) {
283     SetSecondParticleCut(fSecondParticleCut); // this will set the myAnalysis pointer inside the cut
284   }
285   if ( fPairCut ) {
286     SetPairCut(fPairCut); // this will set the myAnalysis pointer inside the cut
287   }
288
289   AliFemtoCorrFctnIterator iter;
290   for (iter=aAna.fCorrFctnCollection->begin(); iter!=aAna.fCorrFctnCollection->end();iter++){
291     AliFemtoCorrFctn* fctn = (*iter)->Clone();
292     if (fctn) AddCorrFctn(fctn);
293   }
294
295   fNumEventsToMix = aAna.fNumEventsToMix;
296
297   fMinSizePartCollection = aAna.fMinSizePartCollection;  // minimum # particles in ParticleCollection
298
299   fVerbose = aAna.fVerbose;
300
301   fPerformSharedDaughterCut = aAna.fPerformSharedDaughterCut;
302
303   return *this;
304 }
305 //______________________
306 AliFemtoCorrFctn* AliFemtoSimpleAnalysis::CorrFctn(int n){
307   // return pointer to n-th correlation function
308   if ( n<0 || n > (int)fCorrFctnCollection->size() )
309     return NULL;
310   AliFemtoCorrFctnIterator iter=fCorrFctnCollection->begin();
311   for (int i=0; i<n ;i++){
312     iter++;
313   }
314   return *iter;
315 }
316 //____________________________
317 AliFemtoString AliFemtoSimpleAnalysis::Report()
318 {
319   // Create a simple report from the analysis execution
320   cout << "AliFemtoSimpleAnalysis - constructing Report..."<<endl;
321   string temp = "-----------\nHbt Analysis Report:\n";
322   temp += "\nEvent Cuts:\n";
323   temp += fEventCut->Report();
324   temp += "\nParticle Cuts - First Particle:\n";
325   temp += fFirstParticleCut->Report();
326   temp += "\nParticle Cuts - Second Particle:\n";
327   temp += fSecondParticleCut->Report();
328   temp += "\nPair Cuts:\n";
329   temp += fPairCut->Report();
330   temp += "\nCorrelation Functions:\n";
331   AliFemtoCorrFctnIterator iter;
332   if ( fCorrFctnCollection->size()==0 ) {
333     cout << "AliFemtoSimpleAnalysis-Warning : no correlations functions in this analysis " << endl;
334   }
335   for (iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
336     temp += (*iter)->Report();
337     temp += "\n";
338   }
339   temp += "-------------\n";
340   AliFemtoString returnThis=temp;
341   return returnThis;
342 }
343 //_________________________
344 void AliFemtoSimpleAnalysis::ProcessEvent(const AliFemtoEvent* hbtEvent) {
345   // Add event to processed events
346
347   fPicoEvent=0; // we will get a new pico event, if not prevent corr. fctn to access old pico event
348   AddEventProcessed();
349   // startup for EbyE
350   EventBegin(hbtEvent);
351   // event cut and event cut monitor
352   bool tmpPassEvent = fEventCut->Pass(hbtEvent);
353   if (!tmpPassEvent)
354     fEventCut->FillCutMonitor(hbtEvent, tmpPassEvent);
355   if (tmpPassEvent) {
356     //  cout << "AliFemtoSimpleAnalysis::ProcessEvent() - Event has passed cut - build picoEvent from " <<
357     //   hbtEvent->TrackCollection()->size() << " tracks in TrackCollection" << endl;
358     //  cout << "Event has passed cut with " << hbtEvent->TrackCollection()->size() << " tracks" << endl;
359     // OK, analysis likes the event-- build a pico event from it, using tracks the analysis likes...
360     fPicoEvent = new AliFemtoPicoEvent; // this is what we will make pairs from and put in Mixing Buffer
361     // no memory leak. we will delete picoevents when they come out of the mixing buffer
362     FillHbtParticleCollection(fFirstParticleCut,(AliFemtoEvent*)hbtEvent,fPicoEvent->FirstParticleCollection(), fPerformSharedDaughterCut);
363     if ( !(AnalyzeIdenticalParticles()) )
364       FillHbtParticleCollection(fSecondParticleCut,(AliFemtoEvent*)hbtEvent,fPicoEvent->SecondParticleCollection(),
365                                 fPerformSharedDaughterCut);
366     //cout <<"AliFemtoSimpleAnalysis::ProcessEvent - #particles in First, Second Collections: " <<
367 //       fPicoEvent->FirstParticleCollection()->size() << " " <<
368 //       fPicoEvent->SecondParticleCollection()->size() << endl;
369
370     if (fVerbose)
371     cout << "#particles in Collection 1, 2: " <<
372        fPicoEvent->FirstParticleCollection()->size() << " " <<
373        fPicoEvent->SecondParticleCollection()->size() << endl;
374     fEventCut->FillCutMonitor(fPicoEvent->FirstParticleCollection(),fPicoEvent->SecondParticleCollection()); //MJ!
375
376
377     // mal - implement a switch which allows only using events with ParticleCollections containing a minimum
378     // number of entries (jun2002)
379     if ((fPicoEvent->FirstParticleCollection()->size() >= fMinSizePartCollection )
380         && ( AnalyzeIdenticalParticles() || (fPicoEvent->SecondParticleCollection()->size() >= fMinSizePartCollection ))) {
381       fEventCut->FillCutMonitor(hbtEvent, tmpPassEvent);
382
383
384 //------------------------------------------------------------------------------
385 //   Temporary comment:
386 //      This whole section rewritten so that all pairs are built using the
387 //      same code... easier to read and manage, and MakePairs() can be called by
388 //      derived classes.  Also, the requirement of a full mixing buffer before
389 //      mixing is removed.
390 //                          Dan Magestro, 11/2002
391
392       //------ Make real pairs. If identical, make pairs for one collection ------//
393
394       if (AnalyzeIdenticalParticles()) {
395         MakePairs("real", fPicoEvent->FirstParticleCollection() );
396       }
397       else {
398         MakePairs("real", fPicoEvent->FirstParticleCollection(),
399                           fPicoEvent->SecondParticleCollection() );
400       }
401
402       if (fVerbose)
403        cout << "AliFemtoSimpleAnalysis::ProcessEvent() - reals done ";
404
405       //---- Make pairs for mixed events, looping over events in mixingBuffer ----//
406
407       AliFemtoPicoEvent* storedEvent;
408       AliFemtoPicoEventIterator fPicoEventIter;
409       for (fPicoEventIter=MixingBuffer()->begin();fPicoEventIter!=MixingBuffer()->end();fPicoEventIter++){
410         storedEvent = *fPicoEventIter;
411         if (AnalyzeIdenticalParticles()) {
412           MakePairs("mixed",fPicoEvent->FirstParticleCollection(),
413                             storedEvent->FirstParticleCollection() );
414         }
415         else {
416           MakePairs("mixed",fPicoEvent->FirstParticleCollection(),
417                             storedEvent->SecondParticleCollection() );
418
419           MakePairs("mixed",storedEvent->FirstParticleCollection(),
420                             fPicoEvent->SecondParticleCollection() );
421         }
422       }
423
424       if (fVerbose)
425        cout << " - mixed done   " << endl;
426
427       //--------- If mixing buffer is full, delete oldest event ---------//
428
429       if ( MixingBufferFull() ) {
430         delete MixingBuffer()->back();
431         MixingBuffer()->pop_back();
432       }
433
434       //-------- Add current event (fPicoEvent) to mixing buffer --------//
435
436       MixingBuffer()->push_front(fPicoEvent);
437
438
439 // Temporary comment: End of rewritten section... Dan Magestro, 11/2002
440 //------------------------------------------------------------------------------
441
442
443     }  // if ParticleCollections are big enough (mal jun2002)
444     else{
445       fEventCut->FillCutMonitor(hbtEvent, !tmpPassEvent);
446       delete fPicoEvent;
447     }
448   }   // if currentEvent is accepted by currentAnalysis
449   EventEnd(hbtEvent);  // cleanup for EbyE
450   //cout << "AliFemtoSimpleAnalysis::ProcessEvent() - return to caller ... " << endl;
451 }
452 //_________________________
453 void AliFemtoSimpleAnalysis::MakePairs(const char* typeIn, AliFemtoParticleCollection *partCollection1,
454                                        AliFemtoParticleCollection *partCollection2){
455 // Build pairs, check pair cuts, and call CFs' AddRealPair() or
456 // AddMixedPair() methods. If no second particle collection is
457 // specfied, make pairs within first particle collection.
458
459   string type = typeIn;
460
461   //  int swpart = ((long int) partCollection1) % 2;
462   int swpart = fNeventsProcessed % 2;
463
464   AliFemtoPair* tPair = new AliFemtoPair;
465
466   AliFemtoCorrFctnIterator tCorrFctnIter;
467
468   AliFemtoParticleIterator tPartIter1, tPartIter2;
469
470   AliFemtoParticleIterator tStartOuterLoop = partCollection1->begin();  // always
471   AliFemtoParticleIterator tEndOuterLoop   = partCollection1->end();    // will be one less if identical
472   AliFemtoParticleIterator tStartInnerLoop;
473   AliFemtoParticleIterator tEndInnerLoop;
474   if (partCollection2) {                        // Two collections:
475     tStartInnerLoop = partCollection2->begin();  //   Full inner & outer loops
476     tEndInnerLoop   = partCollection2->end();    //
477   }
478   else {                                        // One collection:
479     tEndOuterLoop--;                             //   Outer loop goes to next-to-last particle
480     tEndInnerLoop = partCollection1->end() ;     //   Inner loop goes to last particle
481   }
482   for (tPartIter1=tStartOuterLoop;tPartIter1!=tEndOuterLoop;tPartIter1++) {
483     if (!partCollection2){
484       tStartInnerLoop = tPartIter1;
485       tStartInnerLoop++;
486     }
487     tPair->SetTrack1(*tPartIter1);
488     for (tPartIter2 = tStartInnerLoop; tPartIter2!=tEndInnerLoop;tPartIter2++) {
489       tPair->SetTrack2(*tPartIter2);
490
491       // The following lines have to be uncommented if you want pairCutMonitors
492       // they are not in // for speed reasons
493       //bool tmpPassPair = fPairCut->Pass(tPair);
494       //fPairCut->FillCutMonitor(tPair, tmpPassPair);
495       // // if ( tmpPassPair )
496
497       //---- If pair passes cut, loop over CF's and add pair to real/mixed ----//
498
499       if (!partCollection2) {
500         if (swpart) {
501           tPair->SetTrack1(*tPartIter2);
502           tPair->SetTrack2(*tPartIter1);
503           swpart = 0;
504         }
505         else {
506           tPair->SetTrack1(*tPartIter1);
507           tPair->SetTrack2(*tPartIter2);
508           swpart = 1;
509         }
510       }
511
512       if (fPairCut->Pass(tPair)){
513         for (tCorrFctnIter=fCorrFctnCollection->begin();
514              tCorrFctnIter!=fCorrFctnCollection->end();tCorrFctnIter++){
515           AliFemtoCorrFctn* tCorrFctn = *tCorrFctnIter;
516           if(type == "real")
517             tCorrFctn->AddRealPair(tPair);
518           else if(type == "mixed")
519             tCorrFctn->AddMixedPair(tPair);
520           else
521             cout << "Problem with pair type, type = " << type.c_str() << endl;
522         }
523       }
524
525     }    // loop over second particle
526
527   }      // loop over first particle
528
529   delete tPair;
530
531 }
532 //_________________________
533 void AliFemtoSimpleAnalysis::EventBegin(const AliFemtoEvent* ev){
534   // Perform initialization operations at the beginning of the event processing
535   //cout << " AliFemtoSimpleAnalysis::EventBegin(const AliFemtoEvent* ev) " << endl;
536   fFirstParticleCut->EventBegin(ev);
537   fSecondParticleCut->EventBegin(ev);
538   fPairCut->EventBegin(ev);
539   for (AliFemtoCorrFctnIterator iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
540     (*iter)->EventBegin(ev);
541   }
542 }
543 //_________________________
544 void AliFemtoSimpleAnalysis::EventEnd(const AliFemtoEvent* ev){
545   // Fiinsh operations at the end of event processing
546   fFirstParticleCut->EventEnd(ev);
547   fSecondParticleCut->EventEnd(ev);
548   fPairCut->EventEnd(ev);
549   for (AliFemtoCorrFctnIterator iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
550     (*iter)->EventEnd(ev);
551   }
552 }
553 //_________________________
554 void AliFemtoSimpleAnalysis::Finish(){
555   // Perform finishing operations after all events are processed
556   AliFemtoCorrFctnIterator iter;
557   for (iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
558     (*iter)->Finish();
559   }
560 }
561 //_________________________
562 void AliFemtoSimpleAnalysis::AddEventProcessed() {
563   // Increase count of processed events
564   fNeventsProcessed++;
565 }
566 //_________________________
567 TList* AliFemtoSimpleAnalysis::ListSettings()
568 {
569   // Collect settings list
570   TList *tListSettings = new TList();
571
572   TList *p1Cut = fFirstParticleCut->ListSettings();
573
574   TListIter nextp1(p1Cut);
575   while (TObject *obj = nextp1.Next()) {
576     TString cuts(obj->GetName());
577     cuts.Prepend("AliFemtoSimpleAnalysis.");
578     tListSettings->Add(new TObjString(cuts.Data()));
579   }
580
581   if (fSecondParticleCut != fFirstParticleCut) {
582     TList *p2Cut = fSecondParticleCut->ListSettings();
583
584     TIter nextp2(p2Cut);
585     while (TObject *obj = nextp2()) {
586       TString cuts(obj->GetName());
587       cuts.Prepend("AliFemtoSimpleAnalysis.");
588       tListSettings->Add(new TObjString(cuts.Data()));
589     }
590   }
591
592   TList *pairCut = fPairCut->ListSettings();
593
594   TIter nextpair(pairCut);
595   while (TObject *obj = nextpair()) {
596     TString cuts(obj->GetName());
597     cuts.Prepend("AliFemtoSimpleAnalysis.");
598     tListSettings->Add(new TObjString(cuts.Data()));
599   }
600
601   return tListSettings;
602
603 }
604
605 //_________________________
606 TList* AliFemtoSimpleAnalysis::GetOutputList()
607 {
608   // Collect the list of output objects
609   // to be written
610   TList *tOutputList = new TList();
611
612   TList *p1Cut = fFirstParticleCut->GetOutputList();
613
614   TListIter nextp1(p1Cut);
615   while (TObject *obj = nextp1.Next()) {
616     tOutputList->Add(obj);
617   }
618   delete p1Cut;
619
620   if (fSecondParticleCut != fFirstParticleCut) {
621     TList *p2Cut = fSecondParticleCut->GetOutputList();
622
623     TIter nextp2(p2Cut);
624     while (TObject *obj = nextp2()) {
625       tOutputList->Add(obj);
626     }
627     delete p2Cut;
628   }
629
630   TList *pairCut = fPairCut->GetOutputList();
631
632   TIter nextpair(pairCut);
633   while (TObject *obj = nextpair()) {
634     tOutputList->Add(obj);
635   }
636   delete pairCut;
637
638   TList *eventCut = fEventCut->GetOutputList();
639
640   TIter nextevent(eventCut);
641   while (TObject *obj = nextevent()) {
642     tOutputList->Add(obj);
643   }
644   delete eventCut;
645
646   AliFemtoCorrFctnIterator iter;
647   for (iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
648     TList *tListCf = (*iter)->GetOutputList();
649
650     TIter nextListCf(tListCf);
651     while (TObject *obj = nextListCf()) {
652       tOutputList->Add(obj);
653     }
654     delete tListCf;
655   }
656
657   return tOutputList;
658
659 }