1 //_________________________________________________________
2 ////////////////////////////////////////////////////////////////////////////
4 // class AliHBTAnalysis
6 // Central Object Of HBTAnalyser:
7 // This class performs main looping within HBT Analysis
8 // User must plug a reader of Type AliHBTReader
9 // User plugs in coorelation and monitor functions
10 // as well as monitor functions
12 // HBT Analysis Tool, which is integral part of AliRoot,
13 // ALICE Off-Line framework:
15 // Piotr.Skowronski@cern.ch
16 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
18 ////////////////////////////////////////////////////////////////////////////
19 //_________________________________________________________
21 #include "AliHBTAnalysis.h"
22 #include "AliHBTEvent.h"
23 #include "AliHBTReader.h"
24 #include "AliHBTPair.h"
25 #include "AliHBTFunction.h"
26 #include "AliHBTMonitorFunction.h"
27 #include "AliHBTEventBuffer.h"
28 #include "AliHBTPairCut.h"
32 ClassImp(AliHBTAnalysis)
34 const UInt_t AliHBTAnalysis::fgkFctnArraySize = 100;
35 const UInt_t AliHBTAnalysis::fgkDefaultMixingInfo = 1000;
36 const Int_t AliHBTAnalysis::fgkDefaultBufferSize = 5;
38 AliHBTAnalysis::AliHBTAnalysis():
41 fNParticleFunctions(0),
42 fNParticleAndTrackFunctions(0),
43 fNTrackMonitorFunctions(0),
44 fNParticleMonitorFunctions(0),
45 fNParticleAndTrackMonitorFunctions(0),
46 fTrackFunctions ( new AliHBTOnePairFctn* [fgkFctnArraySize]),
47 fParticleFunctions ( new AliHBTOnePairFctn* [fgkFctnArraySize]),
48 fParticleAndTrackFunctions ( new AliHBTTwoPairFctn* [fgkFctnArraySize]),
49 fParticleMonitorFunctions ( new AliHBTMonOneParticleFctn* [fgkFctnArraySize]),
50 fTrackMonitorFunctions ( new AliHBTMonOneParticleFctn* [fgkFctnArraySize]),
51 fParticleAndTrackMonitorFunctions ( new AliHBTMonTwoParticleFctn* [fgkFctnArraySize]),
52 fPairCut(new AliHBTEmptyPairCut()),//empty cut - accepts all particles
54 fDisplayMixingInfo(fgkDefaultMixingInfo),
56 fkPass(&AliHBTAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair
57 fkPass1(&AliHBTAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
58 fkPass2(&AliHBTAnalysis::PassPartAndTrack2),
59 fkPassPairProp(&AliHBTAnalysis::PassPairPropPartAndTrack)
64 /*************************************************************************************/
66 AliHBTAnalysis::AliHBTAnalysis(const AliHBTAnalysis& in):
70 fNParticleFunctions(0),
71 fNParticleAndTrackFunctions(0),
72 fNTrackMonitorFunctions(0),
73 fNParticleMonitorFunctions(0),
74 fNParticleAndTrackMonitorFunctions(0),
76 fParticleFunctions(0x0),
77 fParticleAndTrackFunctions(0x0),
78 fParticleMonitorFunctions(0x0),
79 fTrackMonitorFunctions(0x0),
80 fParticleAndTrackMonitorFunctions(0x0),
82 fBufferSize(fgkDefaultBufferSize),
83 fDisplayMixingInfo(fgkDefaultMixingInfo),
85 fkPass(&AliHBTAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair
86 fkPass1(&AliHBTAnalysis::PassPartAndTrack1),
87 fkPass2(&AliHBTAnalysis::PassPartAndTrack2),
88 fkPassPairProp(&AliHBTAnalysis::PassPairPropPartAndTrack)
91 Fatal("AliHBTAnalysis(const AliHBTAnalysis&)","Sensless");
93 /*************************************************************************************/
94 const AliHBTAnalysis& AliHBTAnalysis::operator=(const AliHBTAnalysis& /*right*/)
97 Fatal("AliHBTAnalysis(const AliHBTAnalysis&)","Sensless");
100 /*************************************************************************************/
101 AliHBTAnalysis::~AliHBTAnalysis()
104 //note that we do not delete functions itself
105 // they should be deleted by whom where created
106 //we only store pointers, and we use "new" only for pointers array
109 delete [] fTrackFunctions;
110 delete [] fParticleFunctions;
111 delete [] fParticleAndTrackFunctions;
113 delete [] fParticleMonitorFunctions;
114 delete [] fTrackMonitorFunctions;
115 delete [] fParticleAndTrackMonitorFunctions;
117 delete fPairCut; // always have an copy of an object - we create we dstroy
120 /*************************************************************************************/
122 void AliHBTAnalysis::DeleteFunctions()
124 //Deletes all functions added to analysis
126 for(ii = 0;ii<fNParticleFunctions;ii++)
127 delete fParticleFunctions[ii];
128 fNParticleFunctions = 0;
130 for(ii = 0;ii<fNTrackFunctions;ii++)
131 delete fTrackFunctions[ii];
132 fNTrackFunctions = 0;
134 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
135 delete fParticleAndTrackFunctions[ii];
136 fNParticleAndTrackFunctions = 0;
138 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
139 delete fParticleMonitorFunctions[ii];
140 fNParticleMonitorFunctions = 0;
142 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
143 delete fTrackMonitorFunctions[ii];
144 fNTrackMonitorFunctions = 0;
146 for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
147 delete fParticleAndTrackMonitorFunctions[ii];
148 fNParticleAndTrackMonitorFunctions = 0;
151 /*************************************************************************************/
153 void AliHBTAnalysis::Init()
155 //Initializeation method
156 //calls Init for all functions
158 for(ii = 0;ii<fNParticleFunctions;ii++)
159 fParticleFunctions[ii]->Init();
161 for(ii = 0;ii<fNTrackFunctions;ii++)
162 fTrackFunctions[ii]->Init();
164 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
165 fParticleAndTrackFunctions[ii]->Init();
167 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
168 fParticleMonitorFunctions[ii]->Init();
170 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
171 fTrackMonitorFunctions[ii]->Init();
173 for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
174 fParticleAndTrackMonitorFunctions[ii]->Init();
178 /*************************************************************************************/
180 void AliHBTAnalysis::ResetFunctions()
182 //In case fOwner is true, deletes all functions
183 //in other case, just set number of analysis to 0
184 if (fIsOwner) DeleteFunctions();
187 fNParticleFunctions = 0;
188 fNTrackFunctions = 0;
189 fNParticleAndTrackFunctions = 0;
190 fNParticleMonitorFunctions = 0;
191 fNTrackMonitorFunctions = 0;
192 fNParticleAndTrackMonitorFunctions = 0;
195 /*************************************************************************************/
197 void AliHBTAnalysis::Process(Option_t* option)
199 //default option = "TracksAndParticles"
200 //Main method of the HBT Analysis Package
201 //It triggers reading with the global cut (default is an empty cut)
202 //Than it checks options and data which are read
203 //if everything is OK, then it calls one of the looping methods
204 //depending on tfReaderhe option
205 //These methods differs on what thay are looping on
208 //--------------------------------------------------------------------
209 //ProcessTracksAndParticles - "TracksAndParticles"
211 // it loops over both, tracks(reconstructed) and particles(simulated)
212 // all function gethered in all 3 lists are called for each (double)pair
214 //ProcessTracks - "Tracks"
215 // it loops only on tracks(reconstructed),
216 // functions ONLY from fTrackFunctions list are called
218 //ProcessParticles - "Particles"
219 // it loops only on particles(simulated),
220 // functions ONLY from fParticleAndTrackFunctions list are called
225 Error("Process","The reader is not set");
229 const char *oT = strstr(option,"Tracks");
230 const char *oP = strstr(option,"Particles");
232 Bool_t nonid = IsNonIdentAnalysis();
238 if (nonid) ProcessTracksAndParticlesNonIdentAnal();
239 else ProcessTracksAndParticles();
245 if (nonid) ProcessTracksNonIdentAnal();
246 else ProcessTracks();
252 if (nonid) ProcessParticlesNonIdentAnal();
253 else ProcessParticles();
258 /*************************************************************************************/
260 void AliHBTAnalysis::ProcessTracksAndParticles()
262 //Makes analysis for both tracks and particles
263 //mainly for resolution study and analysies with weighting algirithms
264 //In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
265 //the loops are splited
267 // cut on particles only -- why?
268 // - PID: when we make resolution analysis we want to take only tracks with correct PID
269 // We need cut on tracks because there are data characteristic to
271 AliHBTParticle * part1, * part2;
272 AliHBTParticle * track1, * track2;
274 AliHBTEvent * trackEvent, *partEvent;
275 AliHBTEvent * trackEvent1 = 0x0,*partEvent1 = 0x0;
276 AliHBTEvent * trackEvent2,*partEvent2;
278 // Int_t N1, N2, N=0; //number of particles in current event(we prcess two events in one time)
280 // Int_t nev = fReader->GetNumberOfTrackEvents();
281 AliHBTPair * trackpair = new AliHBTPair();
282 AliHBTPair * partpair = new AliHBTPair();
284 AliHBTPair * tmptrackpair;//temprary pointers to pairs
285 AliHBTPair * tmppartpair;
287 AliHBTEventBuffer partbuffer(fBufferSize);
288 AliHBTEventBuffer trackbuffer(fBufferSize);
292 Bool_t nocorrfctns = (fNParticleFunctions == 0) && (fNTrackFunctions == 0) && (fNParticleAndTrackFunctions == 0);
296 while (fReader->Next() == kFALSE)
299 partEvent= fReader->GetParticleEvent();
300 trackEvent = fReader->GetTrackEvent();
302 if ( !partEvent || !trackEvent )
304 Error("ProcessTracksAndParticles","Can not get event");
308 if ( partEvent->GetNumberOfParticles() != trackEvent->GetNumberOfParticles() )
310 Fatal("ProcessTracksAndParticles",
311 "Event %d: Number of simulated particles (%d) not equal to number of reconstructed tracks (%d)",
312 i,partEvent->GetNumberOfParticles() , trackEvent->GetNumberOfParticles());
316 if(partEvent1 == 0x0)
318 partEvent1 = new AliHBTEvent();
319 partEvent1->SetOwner(kTRUE);
321 trackEvent1 = new AliHBTEvent();
322 trackEvent1->SetOwner(kTRUE);
327 trackEvent1->Reset();
330 for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
332 /***************************************/
333 /****** Looping same events ********/
334 /****** filling numerators ********/
335 /***************************************/
336 if ( (j%fDisplayMixingInfo) == 0)
337 Info("ProcessTracksAndParticles",
338 "Mixing particle %d from event %d with particles from event %d",j,i,i);
340 part1= partEvent->GetParticle(j);
341 track1= trackEvent->GetParticle(j);
343 //PID imperfections ???
344 // if( part1->GetPdgCode() != track1->GetPdgCode() )
346 // Fatal("ProcessTracksAndParticles",
347 // "Event %d: Particle %d: PID of simulated particle (%d) not the same of reconstructed track (%d)",
348 // i,j, part1->GetPdgCode(),track1->GetPdgCode() );
352 Bool_t firstcut = (this->*fkPass1)(part1,track1);
353 if (fBufferSize != 0)
354 if ( (firstcut == kFALSE) || ( (this->*fkPass2)(part1,track1) == kFALSE ) )
356 //accepted by any cut
357 // we have to copy because reader keeps only one event
359 partEvent1->AddParticle(new AliHBTParticle(*part1));
360 trackEvent1->AddParticle(new AliHBTParticle(*track1));
363 if (firstcut) continue;
365 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
366 fParticleMonitorFunctions[ii]->Process(part1);
367 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
368 fTrackMonitorFunctions[ii]->Process(track1);
369 for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
370 fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
372 if (nocorrfctns) continue;
374 for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
376 part2= partEvent->GetParticle(k);
377 if (part1->GetUID() == part2->GetUID()) continue;
378 partpair->SetParticles(part1,part2);
380 track2= trackEvent->GetParticle(k);
381 trackpair->SetParticles(track1,track2);
383 if( (this->*fkPass)(partpair,trackpair) ) //check pair cut
384 { //do not meets crietria of the pair cut, try with swapped pairs
385 if( (this->*fkPass)(partpair->GetSwapedPair(),trackpair->GetSwapedPair()) )
386 continue; //swaped pairs do not meet criteria of pair cut as well, take next particle
388 { //swaped pair meets all the criteria
389 tmppartpair = partpair->GetSwapedPair();
390 tmptrackpair = trackpair->GetSwapedPair();
394 {//meets criteria of the pair cut
395 tmptrackpair = trackpair;
396 tmppartpair = partpair;
399 for(ii = 0;ii<fNParticleFunctions;ii++)
400 fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
402 for(ii = 0;ii<fNTrackFunctions;ii++)
403 fTrackFunctions[ii]->ProcessSameEventParticles(tmptrackpair);
405 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
406 fParticleAndTrackFunctions[ii]->ProcessSameEventParticles(tmptrackpair,tmppartpair);
407 //end of 2nd loop over particles from the same event
408 }//for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
410 /***************************************/
411 /***** Filling denominators *********/
412 /***************************************/
413 if (fBufferSize == 0) continue;
415 partbuffer.ResetIter();
416 trackbuffer.ResetIter();
418 while (( partEvent2 = partbuffer.Next() ))
420 trackEvent2 = trackbuffer.Next();
423 if ( (j%fDisplayMixingInfo) == 0)
424 Info("ProcessTracksAndParticles",
425 "Mixing particle %d from event %d with particles from event %d",j,i,i-m);
427 for(Int_t l = 0; l<partEvent2->GetNumberOfParticles();l++) // ... on all particles
429 part2= partEvent2->GetParticle(l);
430 partpair->SetParticles(part1,part2);
432 track2= trackEvent2->GetParticle(l);
433 trackpair->SetParticles(track1,track2);
435 if( (this->*fkPass)(partpair,trackpair) ) //check pair cut
436 { //do not meets crietria of the
437 if( (this->*fkPass)(partpair->GetSwapedPair(),trackpair->GetSwapedPair()) )
441 tmppartpair = partpair->GetSwapedPair();
442 tmptrackpair = trackpair->GetSwapedPair();
446 {//meets criteria of the pair cut
447 tmptrackpair = trackpair;
448 tmppartpair = partpair;
451 for(ii = 0;ii<fNParticleFunctions;ii++)
452 fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
454 for(ii = 0;ii<fNTrackFunctions;ii++)
455 fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
457 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
458 fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair,tmppartpair);
459 }//for(Int_t l = 0; l<N2;l++) // ... on all particles
462 //end of loop over particles from first event
463 }//for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
464 partEvent1 = partbuffer.Push(partEvent1);
465 trackEvent1 = trackbuffer.Push(trackEvent1);
466 //end of loop over events
467 }//while (fReader->Next() == kFALSE)
469 /*************************************************************************************/
471 void AliHBTAnalysis::ProcessTracks()
473 //In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
474 //the loops are splited
475 AliHBTParticle * track1, * track2;
476 AliHBTEvent * trackEvent;
477 AliHBTEvent * trackEvent1 = 0x0;
478 AliHBTEvent * trackEvent2;
482 AliHBTPair * trackpair = new AliHBTPair();
483 AliHBTPair * tmptrackpair; //temporary pointer
485 AliHBTEventBuffer trackbuffer(fBufferSize);
489 while (fReader->Next() == kFALSE)
492 trackEvent = fReader->GetTrackEvent();
493 if (!trackEvent) continue;
495 if(trackEvent1 == 0x0)
497 trackEvent1 = new AliHBTEvent();
498 trackEvent1->SetOwner(kTRUE);
502 trackEvent1->Reset();
505 for (Int_t j = 0; j<trackEvent->GetNumberOfParticles() ; j++)
507 /***************************************/
508 /****** Looping same events ********/
509 /****** filling numerators ********/
510 /***************************************/
511 if ( (j%fDisplayMixingInfo) == 0)
512 Info("ProcessTracks",
513 "Mixing particle %d from event %d with particles from event %d",j,i,i);
515 track1= trackEvent->GetParticle(j);
516 Bool_t firstcut = fPairCut->GetFirstPartCut()->Pass(track1);
518 if (fBufferSize != 0)
519 if ( (firstcut == kFALSE) || (fPairCut->GetSecondPartCut()->Pass(track1) == kFALSE) )
521 //accepted by any cut
522 // we have to copy because reader keeps only one event
523 trackEvent1->AddParticle(new AliHBTParticle(*track1));
526 if (firstcut) continue;
528 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
529 fTrackMonitorFunctions[ii]->Process(track1);
531 if ( fNTrackFunctions ==0 ) continue;
533 for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
535 track2= trackEvent->GetParticle(k);
536 if (track1->GetUID() == track2->GetUID()) continue;
538 trackpair->SetParticles(track1,track2);
539 if(fPairCut->Pass(trackpair)) //check pair cut
540 { //do not meets crietria of the
541 if( fPairCut->Pass(trackpair->GetSwapedPair()) ) continue;
542 else tmptrackpair = trackpair->GetSwapedPair();
546 tmptrackpair = trackpair;
548 for(ii = 0;ii<fNTrackFunctions;ii++)
549 fTrackFunctions[ii]->ProcessSameEventParticles(tmptrackpair);
551 /***************************************/
552 /***** Filling denominators *********/
553 /***************************************/
555 if (fBufferSize == 0) continue;
557 trackbuffer.ResetIter();
560 while (( trackEvent2 = trackbuffer.Next() ))
563 if ( (j%fDisplayMixingInfo) == 0)
564 Info("ProcessTracks",
565 "Mixing track %d from event %d with tracks from event %d",j,i,i-m);
566 for(Int_t l = 0; l<trackEvent2->GetNumberOfParticles();l++) // ... on all particles
569 track2= trackEvent2->GetParticle(l);
570 trackpair->SetParticles(track1,track2);
572 if( fPairCut->Pass(trackpair) ) //check pair cut
573 { //do not meets crietria of the
574 if( fPairCut->Pass(trackpair->GetSwapedPair()) )
578 tmptrackpair = trackpair->GetSwapedPair();
582 {//meets criteria of the pair cut
583 tmptrackpair = trackpair;
586 for(ii = 0;ii<fNTrackFunctions;ii++)
587 fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
589 }//for(Int_t l = 0; l<N2;l++) // ... on all particles
592 trackEvent1 = trackbuffer.Push(trackEvent1);
593 }//while (fReader->Next() == kFALSE)
596 /*************************************************************************************/
598 void AliHBTAnalysis::ProcessParticles()
600 //In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
601 //the loops are splited
602 AliHBTParticle * part1, * part2;
603 AliHBTEvent * partEvent;
604 AliHBTEvent * partEvent1 = 0x0;
605 AliHBTEvent * partEvent2;
609 AliHBTPair * partpair = new AliHBTPair();
610 AliHBTPair * tmppartpair; //temporary pointer
612 AliHBTEventBuffer partbuffer(fBufferSize);
616 while (fReader->Next() == kFALSE)
619 partEvent = fReader->GetParticleEvent();
620 if (!partEvent) continue;
622 if(partEvent1 == 0x0)
624 partEvent1 = new AliHBTEvent();
625 partEvent1->SetOwner(kTRUE);
632 for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
634 /***************************************/
635 /****** Looping same events ********/
636 /****** filling numerators ********/
637 /***************************************/
638 if ( (j%fDisplayMixingInfo) == 0)
639 Info("ProcessParticles",
640 "Mixing particle %d from event %d with particles from event %d",j,i,i);
642 part1 = partEvent->GetParticle(j);
643 Bool_t firstcut = fPairCut->GetFirstPartCut()->Pass(part1);
645 if (fBufferSize != 0) //useless in case
646 if ( (firstcut == kFALSE) || (fPairCut->GetSecondPartCut()->Pass(part1) == kFALSE) )
648 //accepted by any cut
649 // we have to copy because reader keeps only one event
650 partEvent1->AddParticle(new AliHBTParticle(*part1));
653 if (firstcut) continue;
655 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
656 fParticleMonitorFunctions[ii]->Process(part1);
658 if ( fNParticleFunctions == 0 ) continue;
660 for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
662 part2= partEvent->GetParticle(k);
663 if (part1->GetUID() == part2->GetUID()) continue;
665 partpair->SetParticles(part1,part2);
666 if(fPairCut->Pass(partpair)) //check pair cut
667 { //do not meets crietria of the
668 if( fPairCut->Pass(partpair->GetSwapedPair()) ) continue;
669 else tmppartpair = partpair->GetSwapedPair();
673 tmppartpair = partpair;
675 for(ii = 0;ii<fNParticleFunctions;ii++)
676 fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
678 /***************************************/
679 /***** Filling denominators *********/
680 /***************************************/
682 if (fBufferSize == 0) continue;
684 partbuffer.ResetIter();
687 while (( partEvent2 = partbuffer.Next() ))
690 if ( (j%fDisplayMixingInfo) == 0)
691 Info("ProcessParticles",
692 "Mixing particle %d from event %d with particles from event %d",j,i,i-m);
693 for(Int_t l = 0; l<partEvent2->GetNumberOfParticles();l++) // ... on all particles
696 part2= partEvent2->GetParticle(l);
697 partpair->SetParticles(part1,part2);
699 if( fPairCut->Pass(partpair) ) //check pair cut
700 { //do not meets crietria of the
701 if( fPairCut->Pass(partpair->GetSwapedPair()) )
705 tmppartpair = partpair->GetSwapedPair();
709 {//meets criteria of the pair cut
710 tmppartpair = partpair;
713 for(ii = 0;ii<fNParticleFunctions;ii++)
714 fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
716 }//for(Int_t l = 0; l<N2;l++) // ... on all particles
719 partEvent1 = partbuffer.Push(partEvent1);
720 }//while (fReader->Next() == kFALSE)
722 /*************************************************************************************/
724 void AliHBTAnalysis::WriteFunctions()
726 //Calls Write for all defined functions in analysis
727 //== writes all results
729 for(ii = 0;ii<fNParticleFunctions;ii++)
730 fParticleFunctions[ii]->Write();
732 for(ii = 0;ii<fNTrackFunctions;ii++)
733 fTrackFunctions[ii]->Write();
735 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
736 fParticleAndTrackFunctions[ii]->Write();
738 for(ii = 0;ii<fNParticleMonitorFunctions;ii++)
739 fParticleMonitorFunctions[ii]->Write();
741 for(ii = 0;ii<fNTrackMonitorFunctions;ii++)
742 fTrackMonitorFunctions[ii]->Write();
744 for(ii = 0;ii<fNParticleAndTrackMonitorFunctions;ii++)
745 fParticleAndTrackMonitorFunctions[ii]->Write();
747 /*************************************************************************************/
749 void AliHBTAnalysis::SetGlobalPairCut(AliHBTPairCut* cut)
751 //Sets the global cut
754 Error("AliHBTAnalysis::SetGlobalPairCut","Pointer is NULL. Ignoring");
757 fPairCut = (AliHBTPairCut*)cut->Clone();
760 /*************************************************************************************/
762 void AliHBTAnalysis::AddTrackFunction(AliHBTOnePairFctn* f)
764 //Adds track function
765 if (f == 0x0) return;
766 if (fNTrackFunctions == fgkFctnArraySize)
768 Error("AliHBTAnalysis::AddTrackFunction","Can not add this function, not enough place in the array.");
770 fTrackFunctions[fNTrackFunctions] = f;
773 /*************************************************************************************/
775 void AliHBTAnalysis::AddParticleFunction(AliHBTOnePairFctn* f)
777 //adds particle function
778 if (f == 0x0) return;
780 if (fNParticleFunctions == fgkFctnArraySize)
782 Error("AliHBTAnalysis::AddParticleFunction","Can not add this function, not enough place in the array.");
784 fParticleFunctions[fNParticleFunctions] = f;
785 fNParticleFunctions++;
787 /*************************************************************************************/
789 void AliHBTAnalysis::AddParticleAndTrackFunction(AliHBTTwoPairFctn* f)
791 //add resolution function
792 if (f == 0x0) return;
793 if (fNParticleAndTrackFunctions == fgkFctnArraySize)
795 Error("AliHBTAnalysis::AddParticleAndTrackFunction","Can not add this function, not enough place in the array.");
797 fParticleAndTrackFunctions[fNParticleAndTrackFunctions] = f;
798 fNParticleAndTrackFunctions++;
800 /*************************************************************************************/
802 void AliHBTAnalysis::AddParticleMonitorFunction(AliHBTMonOneParticleFctn* f)
804 //add particle monitoring function
805 if (f == 0x0) return;
807 if (fNParticleMonitorFunctions == fgkFctnArraySize)
809 Error("AliHBTAnalysis::AddParticleMonitorFunction","Can not add this function, not enough place in the array.");
811 fParticleMonitorFunctions[fNParticleMonitorFunctions] = f;
812 fNParticleMonitorFunctions++;
814 /*************************************************************************************/
816 void AliHBTAnalysis::AddTrackMonitorFunction(AliHBTMonOneParticleFctn* f)
818 //add track monitoring function
819 if (f == 0x0) return;
821 if (fNTrackMonitorFunctions == fgkFctnArraySize)
823 Error("AliHBTAnalysis::AddTrackMonitorFunction","Can not add this function, not enough place in the array.");
825 fTrackMonitorFunctions[fNTrackMonitorFunctions] = f;
826 fNTrackMonitorFunctions++;
828 /*************************************************************************************/
830 void AliHBTAnalysis::AddParticleAndTrackMonitorFunction(AliHBTMonTwoParticleFctn* f)
832 //add resolution monitoring function
833 if (f == 0x0) return;
834 if (fNParticleAndTrackMonitorFunctions == fgkFctnArraySize)
836 Error("AliHBTAnalysis::AddParticleAndTrackMonitorFunction","Can not add this function, not enough place in the array.");
838 fParticleAndTrackMonitorFunctions[fNParticleAndTrackMonitorFunctions] = f;
839 fNParticleAndTrackMonitorFunctions++;
843 /*************************************************************************************/
844 /*************************************************************************************/
846 Bool_t AliHBTAnalysis::RunCoherencyCheck()
848 //Checks if both HBTRuns are similar
849 //return true if error found
850 //if they seem to be OK return false
852 Info("RunCoherencyCheck","Checking HBT Runs Coherency");
854 Info("RunCoherencyCheck","Number of events ...");
855 if (fReader->GetNumberOfPartEvents() == fReader->GetNumberOfTrackEvents() ) //check whether there is the same number of events
857 Info("RunCoherencyCheck","OK. %d found\n",fReader->GetNumberOfTrackEvents());
860 { //if not the same - ERROR
861 Error("AliHBTAnalysis::RunCoherencyCheck()",
862 "Number of simulated events (%d) is not equal to number of reconstructed events(%d)",
863 fReader->GetNumberOfPartEvents(),fReader->GetNumberOfTrackEvents());
867 Info("RunCoherencyCheck","Checking number of Particles AND Particles Types in each event ...");
869 AliHBTEvent *partEvent;
870 AliHBTEvent *trackEvent;
871 for( i = 0; i<fReader->GetNumberOfTrackEvents();i++)
873 partEvent= fReader->GetParticleEvent(i); //gets the "ith" event
874 trackEvent = fReader->GetTrackEvent(i);
876 if ( (partEvent == 0x0) && (partEvent == 0x0) ) continue;
877 if ( (partEvent == 0x0) || (partEvent == 0x0) )
879 Error("AliHBTAnalysis::RunCoherencyCheck()",
880 "One event is NULL and the other one not. Event Number %d",i);
884 if ( partEvent->GetNumberOfParticles() != trackEvent->GetNumberOfParticles() )
886 Error("AliHBTAnalysis::RunCoherencyCheck()",
887 "Event %d: Number of simulated particles (%d) not equal to number of reconstructed tracks (%d)",
888 i,partEvent->GetNumberOfParticles() , trackEvent->GetNumberOfParticles());
892 for (Int_t j = 0; j<partEvent->GetNumberOfParticles(); j++)
894 if( partEvent->GetParticle(j)->GetPdgCode() != trackEvent->GetParticle(j)->GetPdgCode() )
896 Error("AliHBTAnalysis::RunCoherencyCheck()",
897 "Event %d: Particle %d: PID of simulated particle (%d) not the same of reconstructed track (%d)",
898 i,j, partEvent->GetParticle(j)->GetPdgCode(),trackEvent->GetParticle(j)->GetPdgCode() );
904 Info("RunCoherencyCheck"," Done");
905 Info("RunCoherencyCheck"," Everything looks OK");
909 /*************************************************************************************/
911 void AliHBTAnalysis::ProcessTracksAndParticlesNonIdentAnal()
913 //Performs analysis for both, tracks and particles
915 AliHBTParticle * part1, * part2;
916 AliHBTParticle * track1, * track2;
918 AliHBTEvent * trackEvent1=0x0,*partEvent1=0x0;
919 AliHBTEvent * trackEvent2=0x0,*partEvent2=0x0;
920 AliHBTEvent * trackEvent3=0x0,*partEvent3=0x0;
922 AliHBTEvent * rawtrackEvent, *rawpartEvent;//this we get from Reader
924 AliHBTPair * trackpair = new AliHBTPair();
925 AliHBTPair * partpair = new AliHBTPair();
927 AliHBTEventBuffer partbuffer(fBufferSize);
928 AliHBTEventBuffer trackbuffer(fBufferSize);
932 trackEvent1 = new AliHBTEvent();
933 partEvent1 = new AliHBTEvent();
934 trackEvent1->SetOwner(kFALSE);
935 partEvent1->SetOwner(kFALSE);;
937 Bool_t nocorrfctns = (fNParticleFunctions == 0) && (fNTrackFunctions == 0) && (fNParticleAndTrackFunctions == 0);
941 Info("ProcessTracksAndParticlesNonIdentAnal","**************************************");
942 Info("ProcessTracksAndParticlesNonIdentAnal","***** NON IDENT MODE ****************");
943 Info("ProcessTracksAndParticlesNonIdentAnal","**************************************");
945 for (Int_t i = 0;;i++)//infinite loop
947 if (fReader->Next()) break; //end when no more events available
949 rawpartEvent = fReader->GetParticleEvent();
950 rawtrackEvent = fReader->GetTrackEvent();
951 if ( (rawpartEvent == 0x0) || (rawtrackEvent == 0x0) ) continue;//in case of any error
953 if ( rawpartEvent->GetNumberOfParticles() != rawtrackEvent->GetNumberOfParticles() )
955 Fatal("ProcessTracksAndParticlesNonIdentAnal",
956 "Event %d: Number of simulated particles (%d) not equal to number of reconstructed tracks (%d)",
957 i,rawpartEvent->GetNumberOfParticles() , rawtrackEvent->GetNumberOfParticles());
961 /********************************/
963 /********************************/
964 if ( ( (partEvent2==0x0) || (trackEvent2==0x0)) )//in case fBufferSize == 0 and pointers are created do not eneter
966 partEvent2 = new AliHBTEvent();
967 trackEvent2 = new AliHBTEvent();
968 partEvent2->SetOwner(kTRUE);
969 trackEvent2->SetOwner(kTRUE);
972 FilterOut(partEvent1, partEvent2, rawpartEvent, trackEvent1, trackEvent2, rawtrackEvent);
974 for (Int_t j = 0; j<partEvent1->GetNumberOfParticles() ; j++)
976 if ( (j%fDisplayMixingInfo) == 0)
977 Info("ProcessTracksAndParticlesNonIdentAnal",
978 "Mixing particle %d from event %d with particles from event %d",j,i,i);
980 part1= partEvent1->GetParticle(j);
981 track1= trackEvent1->GetParticle(j);
983 //PID reconstruction imperfections
984 // if( part1->GetPdgCode() != track1->GetPdgCode() )
986 // Fatal("ProcessTracksAndParticlesNonIdentAnal",
987 // "Event %d: Particle %d: PID of simulated particle (%d) not the same of reconstructed track (%d)",
988 // i,j, part1->GetPdgCode(),track1->GetPdgCode() );
992 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
993 fParticleMonitorFunctions[ii]->Process(part1);
994 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
995 fTrackMonitorFunctions[ii]->Process(track1);
996 for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
997 fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
999 if (nocorrfctns) continue;
1001 /***************************************/
1002 /****** filling numerators ********/
1003 /****** (particles from event2) ********/
1004 /***************************************/
1006 for (Int_t k = 0; k < partEvent2->GetNumberOfParticles() ; k++) //partEvent1 and partEvent2 are particles from the same event but separated to two groups
1008 part2= partEvent2->GetParticle(k);
1009 if (part1->GetUID() == part2->GetUID()) continue;//this is the same particle but with different PID
1010 partpair->SetParticles(part1,part2);
1012 track2= trackEvent2->GetParticle(k);
1013 trackpair->SetParticles(track1,track2);
1015 if( (this->*fkPassPairProp)(partpair,trackpair) ) //check pair cut
1016 { //do not meets crietria of the pair cut
1020 {//meets criteria of the pair cut
1021 for(ii = 0;ii<fNParticleFunctions;ii++)
1022 fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
1024 for(ii = 0;ii<fNTrackFunctions;ii++)
1025 fTrackFunctions[ii]->ProcessSameEventParticles(trackpair);
1027 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
1028 fParticleAndTrackFunctions[ii]->ProcessSameEventParticles(trackpair,partpair);
1032 if ( fBufferSize == 0) continue;//do not mix diff histograms
1033 /***************************************/
1034 /***** Filling denominators *********/
1035 /***************************************/
1036 partbuffer.ResetIter();
1037 trackbuffer.ResetIter();
1041 while ( (partEvent3 = partbuffer.Next() ) != 0x0)
1043 trackEvent3 = trackbuffer.Next();
1045 if ( (j%fDisplayMixingInfo) == 0)
1046 Info("ProcessTracksAndParticlesNonIdentAnal",
1047 "Mixing particle %d from event %d with particles from event %d",j,i,i-(++nmonitor));
1049 for (Int_t k = 0; k < partEvent3->GetNumberOfParticles() ; k++)
1051 part2= partEvent3->GetParticle(k);
1052 partpair->SetParticles(part1,part2);
1054 track2= trackEvent3->GetParticle(k);
1055 trackpair->SetParticles(track1,track2);
1057 if( (this->*fkPassPairProp)(partpair,trackpair) ) //check pair cut
1058 { //do not meets crietria of the pair cut
1062 {//meets criteria of the pair cut
1064 for(ii = 0;ii<fNParticleFunctions;ii++)
1065 fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
1067 for(ii = 0;ii<fNTrackFunctions;ii++)
1068 fTrackFunctions[ii]->ProcessDiffEventParticles(trackpair);
1070 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
1071 fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(trackpair,partpair);
1073 }// for particles event2
1075 }//for over particles in event1
1077 partEvent2 = partbuffer.Push(partEvent2);
1078 trackEvent2 = trackbuffer.Push(trackEvent2);
1080 }//end of loop over events (1)
1082 partbuffer.SetOwner(kTRUE);
1083 trackbuffer.SetOwner(kTRUE);
1093 /*************************************************************************************/
1095 void AliHBTAnalysis::ProcessTracksNonIdentAnal()
1097 //Process Tracks only with non identical mode
1098 AliHBTParticle * track1, * track2;
1100 AliHBTEvent * trackEvent1=0x0;
1101 AliHBTEvent * trackEvent2=0x0;
1102 AliHBTEvent * trackEvent3=0x0;
1104 AliHBTEvent * rawtrackEvent;
1106 AliHBTPair * trackpair = new AliHBTPair();
1107 AliHBTEventBuffer trackbuffer(fBufferSize);
1111 trackEvent1 = new AliHBTEvent();
1112 trackEvent1->SetOwner(kFALSE);
1116 Info("ProcessTracksNonIdentAnal","**************************************");
1117 Info("ProcessTracksNonIdentAnal","***** NON IDENT MODE ****************");
1118 Info("ProcessTracksNonIdentAnal","**************************************");
1121 for (Int_t i = 0;;i++)//infinite loop
1123 if (fReader->Next()) break; //end when no more events available
1124 rawtrackEvent = fReader->GetTrackEvent();
1126 if (rawtrackEvent == 0x0) continue;//in case of any error
1128 /********************************/
1130 /********************************/
1131 if ( trackEvent2==0x0 )//in case fBufferSize == 0 and pointers are created do not eneter
1133 trackEvent2 = new AliHBTEvent();
1134 trackEvent2->SetOwner(kTRUE);
1137 FilterOut(trackEvent1, trackEvent2, rawtrackEvent);
1139 for (Int_t j = 0; j<trackEvent1->GetNumberOfParticles() ; j++)
1141 if ( (j%fDisplayMixingInfo) == 0)
1142 Info("ProcessTracksNonIdentAnal",
1143 "Mixing particle %d from event %d with particles from event %d",j,i,i);
1145 track1= trackEvent1->GetParticle(j);
1147 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
1148 fTrackMonitorFunctions[ii]->Process(track1);
1150 if (fNTrackFunctions == 0x0) continue;
1152 /***************************************/
1153 /****** filling numerators ********/
1154 /****** (particles from event2) ********/
1155 /***************************************/
1156 for (Int_t k = 0; k < trackEvent2->GetNumberOfParticles() ; k++)
1158 track2= trackEvent2->GetParticle(k);
1159 if (track1->GetUID() == track2->GetUID()) continue;//this is the same particle but with different PID
1160 trackpair->SetParticles(track1,track2);
1163 if( fPairCut->PassPairProp(trackpair)) //check pair cut
1164 { //do not meets crietria of the pair cut
1168 {//meets criteria of the pair cut
1170 for(ii = 0;ii<fNTrackFunctions;ii++)
1171 fTrackFunctions[ii]->ProcessSameEventParticles(trackpair);
1174 if ( fBufferSize == 0) continue;//do not mix diff histograms
1175 /***************************************/
1176 /***** Filling denominators *********/
1177 /***************************************/
1178 trackbuffer.ResetIter();
1181 while ( (trackEvent3 = trackbuffer.Next() ) != 0x0)
1184 if ( (j%fDisplayMixingInfo) == 0)
1185 Info("ProcessTracksNonIdentAnal",
1186 "Mixing particle %d from event %d with particles from event %d",j,i,i-(++nmonitor));
1188 for (Int_t k = 0; k < trackEvent3->GetNumberOfParticles() ; k++)
1191 track2= trackEvent3->GetParticle(k);
1192 trackpair->SetParticles(track1,track2);
1195 if( fPairCut->PassPairProp(trackpair)) //check pair cut
1196 { //do not meets crietria of the pair cut
1200 {//meets criteria of the pair cut
1201 for(ii = 0;ii<fNTrackFunctions;ii++)
1202 fTrackFunctions[ii]->ProcessDiffEventParticles(trackpair);
1204 }// for particles event2
1206 }//for over particles in event1
1208 trackEvent2 = trackbuffer.Push(trackEvent2);
1210 }//end of loop over events (1)
1212 trackbuffer.SetOwner(kTRUE);
1217 /*************************************************************************************/
1219 void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
1221 //process paricles only with non identical mode
1222 AliHBTParticle * part1 = 0x0, * part2 = 0x0;
1224 AliHBTEvent * partEvent1 = 0x0;
1225 AliHBTEvent * partEvent2 = 0x0;
1226 AliHBTEvent * partEvent3 = 0x0;
1228 AliHBTEvent * rawpartEvent = 0x0;
1230 AliHBTPair * partpair = new AliHBTPair();
1231 AliHBTEventBuffer partbuffer(fBufferSize);
1235 partEvent1 = new AliHBTEvent();
1236 partEvent1->SetOwner(kFALSE);
1240 Info("ProcessParticlesNonIdentAnal","**************************************");
1241 Info("ProcessParticlesNonIdentAnal","***** NON IDENT MODE ****************");
1242 Info("ProcessParticlesNonIdentAnal","**************************************");
1244 for (Int_t i = 0;;i++)//infinite loop
1246 if (fReader->Next()) break; //end when no more events available
1248 rawpartEvent = fReader->GetParticleEvent();
1249 if ( rawpartEvent == 0x0 ) continue;//in case of any error
1251 /********************************/
1253 /********************************/
1254 if (partEvent2==0x0)//in case fBufferSize == 0 and pointers are created do not eneter
1256 partEvent2 = new AliHBTEvent();
1257 partEvent2->SetOwner(kTRUE);
1260 FilterOut(partEvent1, partEvent2, rawpartEvent);
1262 for (Int_t j = 0; j<partEvent1->GetNumberOfParticles() ; j++)
1264 if ( (j%fDisplayMixingInfo) == 0)
1265 Info("ProcessParticlesNonIdentAnal",
1266 "Mixing particle %d from event %d with particles from event %d",j,i,i);
1268 part1= partEvent1->GetParticle(j);
1270 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
1271 fParticleMonitorFunctions[ii]->Process(part1);
1273 if (fNParticleFunctions == 0) continue;
1275 /***************************************/
1276 /****** filling numerators ********/
1277 /****** (particles from event2) ********/
1278 /***************************************/
1279 for (Int_t k = 0; k < partEvent2->GetNumberOfParticles() ; k++)
1281 part2= partEvent2->GetParticle(k);
1282 if (part1->GetUID() == part2->GetUID()) continue;//this is the same particle but with different PID
1283 partpair->SetParticles(part1,part2);
1285 if(fPairCut->PassPairProp(partpair) ) //check pair cut
1286 { //do not meets crietria of the pair cut
1290 {//meets criteria of the pair cut
1291 for(ii = 0;ii<fNParticleFunctions;ii++)
1292 fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
1295 if ( fBufferSize == 0) continue;//do not mix diff histograms
1296 /***************************************/
1297 /***** Filling denominators *********/
1298 /***************************************/
1299 partbuffer.ResetIter();
1302 while ( (partEvent3 = partbuffer.Next() ) != 0x0)
1304 if ( (j%fDisplayMixingInfo) == 0)
1305 Info("ProcessParticlesNonIdentAnal",
1306 "Mixing particle %d from event %d with particles from event %d",j,i,i-(++nmonitor));
1308 for (Int_t k = 0; k < partEvent3->GetNumberOfParticles() ; k++)
1310 part2= partEvent3->GetParticle(k);
1311 partpair->SetParticles(part1,part2);
1313 if(fPairCut->PassPairProp(partpair) ) //check pair cut
1314 { //do not meets crietria of the pair cut
1318 {//meets criteria of the pair cut
1319 for(ii = 0;ii<fNParticleFunctions;ii++)
1321 fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
1324 }// for particles event2
1326 }//for over particles in event1
1327 partEvent2 = partbuffer.Push(partEvent2);
1328 }//end of loop over events (1)
1330 partbuffer.SetOwner(kTRUE);
1336 /*************************************************************************************/
1337 void AliHBTAnalysis::FilterOut(AliHBTEvent* outpart1, AliHBTEvent* outpart2, AliHBTEvent* inpart,
1338 AliHBTEvent* outtrack1, AliHBTEvent* outtrack2, AliHBTEvent* intrack) const
1340 //Puts particles accepted as a first particle by global cut in out1
1341 //and as a second particle in out2
1343 AliHBTParticle* part, *track;
1352 for (Int_t i = 0; i < inpart->GetNumberOfParticles(); i++)
1355 part = inpart->GetParticle(i);
1356 track = intrack->GetParticle(i);
1358 if ( ((this->*fkPass1)(part,track)) ) in1 = kFALSE; //if part is rejected by cut1, in1 is false
1359 if ( ((this->*fkPass2)(part,track)) ) in2 = kFALSE; //if part is rejected by cut2, in2 is false
1361 if (gDebug)//to be removed in real analysis
1362 if ( in1 && in2 ) //both cuts accepted, should never happen, just in case
1364 //Particle accpted by both cuts
1365 Error("FilterOut","Particle accepted by both cuts");
1371 outpart1->AddParticle(part);
1372 outtrack1->AddParticle(track);
1378 outpart2->AddParticle(new AliHBTParticle(*part));
1379 outtrack2->AddParticle(new AliHBTParticle(*track));
1384 /*************************************************************************************/
1386 void AliHBTAnalysis::FilterOut(AliHBTEvent* out1, AliHBTEvent* out2, AliHBTEvent* in) const
1388 //Puts particles accepted as a first particle by global cut in out1
1389 //and as a second particle in out2
1390 AliHBTParticle* part;
1395 AliHBTParticleCut *cut1 = fPairCut->GetFirstPartCut();
1396 AliHBTParticleCut *cut2 = fPairCut->GetSecondPartCut();
1400 for (Int_t i = 0; i < in->GetNumberOfParticles(); i++)
1403 part = in->GetParticle(i);
1405 if ( cut1->Pass(part) ) in1 = kFALSE; //if part is rejected by cut1, in1 is false
1406 if ( cut2->Pass(part) ) in2 = kFALSE; //if part is rejected by cut2, in2 is false
1408 if (gDebug)//to be removed in real analysis
1409 if ( in1 && in2 ) //both cuts accepted, should never happen, just in case
1411 //Particle accpted by both cuts
1412 Error("FilterOut","Particle accepted by both cuts");
1418 out1->AddParticle(part);
1424 out2->AddParticle(part);
1429 /*************************************************************************************/
1431 Bool_t AliHBTAnalysis::IsNonIdentAnalysis()
1433 //checks if it is possible to use special analysis for non identical particles
1434 //it means - in global pair cut first particle id is different than second one
1435 //and both are different from 0
1436 //in the future is possible to perform more sophisticated check
1437 //if cuts have excluding requirements
1439 if (fPairCut->IsEmpty())
1442 if (fPairCut->GetFirstPartCut()->IsEmpty())
1445 if (fPairCut->GetSecondPartCut()->IsEmpty())
1448 Int_t id1 = fPairCut->GetFirstPartCut()->GetPID();
1449 Int_t id2 = fPairCut->GetSecondPartCut()->GetPID();
1451 if ( (id1==0) || (id2==0) || (id1==id2) )
1456 /*************************************************************************************/
1458 void AliHBTAnalysis::SetCutsOnParticles()
1460 // -- aplies only to Process("TracksAndParticles")
1461 // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
1462 // Only particles properties are checkes against cuts
1463 fkPass = &AliHBTAnalysis::PassPart;
1464 fkPass1 = &AliHBTAnalysis::PassPart1;
1465 fkPass2 = &AliHBTAnalysis::PassPart2;
1466 fkPassPairProp = &AliHBTAnalysis::PassPairPropPart;
1469 /*************************************************************************************/
1471 void AliHBTAnalysis::SetCutsOnTracks()
1473 // -- aplies only to Process("TracksAndParticles")
1474 // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
1475 // Only tracks properties are checkes against cuts
1476 fkPass = &AliHBTAnalysis::PassTrack;
1477 fkPass1 = &AliHBTAnalysis::PassTrack1;
1478 fkPass2 = &AliHBTAnalysis::PassTrack2;
1479 fkPassPairProp = &AliHBTAnalysis::PassPairPropTrack;
1482 /*************************************************************************************/
1484 void AliHBTAnalysis::SetCutsOnTracksAndParticles()
1486 // -- aplies only to Process("TracksAndParticles")
1487 // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
1488 // Both, tracks and particles, properties are checked against cuts
1489 fkPass = &AliHBTAnalysis::PassPartAndTrack;
1490 fkPass1 = &AliHBTAnalysis::PassPartAndTrack1;
1491 fkPass2 = &AliHBTAnalysis::PassPartAndTrack2;
1492 fkPassPairProp = &AliHBTAnalysis::PassPairPropPartAndTrack;
1494 /*************************************************************************************/
1496 void AliHBTAnalysis::PressAnyKey()
1498 //small utility function that helps to make comfortable macros
1501 fcntl(0, F_SETFL, O_NONBLOCK);
1502 ::Info("","Press Any Key to continue ...");
1505 nread = read(0, &c, 1);
1506 gSystem->ProcessEvents();
1510 /*************************************************************************************/