1 #include "AliHBTAnalysisStavinskyMixing.h"
2 //_________________________________________________________
3 ////////////////////////////////////////////////////////////////////////////
5 // class AliHBTAnalysisStavinskyMixing
7 // Central Object Of HBTAnalyser:
8 // This class performs main looping within HBT Analysis
9 // User must plug a reader of Type AliReader
10 // User plugs in coorelation and monitor functions
11 // as well as monitor functions
13 // HBT Analysis Tool, which is integral part of AliRoot,
14 // ALICE Off-Line framework:
16 // Piotr.Skowronski@cern.ch
17 // more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
19 ////////////////////////////////////////////////////////////////////////////
20 //_________________________________________________________
27 #include "AliAODParticle.h"
28 #include "AliAODPairCut.h"
29 #include "AliEventCut.h"
31 #include "AliEventBuffer.h"
33 #include "AliReader.h"
34 #include "AliHBTPair.h"
35 #include "AliHBTFunction.h"
36 #include "AliHBTMonitorFunction.h"
39 ClassImp(AliHBTAnalysisStavinskyMixing)
42 Int_t AliHBTAnalysisStavinskyMixing::ProcessRecAndSim(AliAOD* aodrec, AliAOD* aodsim)
44 //Does analysis for both tracks and particles
45 //mainly for resolution study and analysies with weighting algirithms
47 // cut on particles only -- why?
48 // - PID: when we make resolution analysis we want to take only tracks with correct PID
49 // We need cut on tracks because there are data characteristic
51 AliVAODParticle * part1, * part2;
52 AliVAODParticle * track1, * track2;
54 AliAOD * trackEvent = aodrec, *partEvent = aodsim;
55 AliAOD* trackEvent1 = new AliAOD();
56 AliAOD* partEvent1 = new AliAOD();
59 // Int_t N1, N2, N=0; //number of particles in current event(we prcess two events in one time)
61 // Int_t nev = fReader->GetNumberOfTrackEvents();
62 static AliHBTPair tpair;
63 static AliHBTPair ppair;
65 AliHBTPair* trackpair = &tpair;
66 AliHBTPair* partpair = &ppair;
68 AliHBTPair * tmptrackpair;//temprary pointers to pairs
69 AliHBTPair * tmppartpair;
75 if ( !partEvent || !trackEvent )
77 Error("ProcessRecAndSim","<<%s>> Can not get event",GetName());
81 if ( partEvent->GetNumberOfParticles() != trackEvent->GetNumberOfParticles() )
83 Error("ProcessRecAndSim",
84 "Number of simulated particles (%d) not equal to number of reconstructed tracks (%d). Skipping Event.",
85 partEvent->GetNumberOfParticles() , trackEvent->GetNumberOfParticles());
90 for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
92 /***************************************/
93 /****** Looping same events ********/
94 /****** filling numerators ********/
95 /***************************************/
96 if ( (j%fDisplayMixingInfo) == 0)
97 Info("ProcessTracksAndParticles",
98 "Mixing particle %d with particles from the same event",j);
100 part1= partEvent->GetParticle(j);
101 track1= trackEvent->GetParticle(j);
103 Bool_t firstcut = (this->*fkPass1)(part1,track1);
104 if (fBufferSize != 0)
105 if ( (firstcut == kFALSE) || ( (this->*fkPass2)(part1,track1) == kFALSE ) )
107 //accepted by any cut
108 // we have to copy because reader keeps only one event
110 partEvent1->AddParticle(part1);
111 trackEvent1->AddParticle(track1);
114 if (firstcut) continue;
116 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
117 fParticleMonitorFunctions[ii]->Process(part1);
118 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
119 fTrackMonitorFunctions[ii]->Process(track1);
120 for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
121 fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
123 if (fNoCorrfctns) continue;
125 for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
127 part2= partEvent->GetParticle(k);
128 if (part1->GetUID() == part2->GetUID()) continue;
129 partpair->SetParticles(part1,part2);
131 track2= trackEvent->GetParticle(k);
132 trackpair->SetParticles(track1,track2);
134 if( (this->*fkPass)(partpair,trackpair) ) //check pair cut
135 { //do not meets crietria of the pair cut, try with swapped pairs
136 if( (this->*fkPass)((AliHBTPair*)partpair->GetSwappedPair(),(AliHBTPair*)trackpair->GetSwappedPair()) )
137 continue; //swaped pairs do not meet criteria of pair cut as well, take next particle
139 { //swaped pair meets all the criteria
140 tmppartpair = (AliHBTPair*)partpair->GetSwappedPair();
141 tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
145 {//meets criteria of the pair cut
146 tmptrackpair = trackpair;
147 tmppartpair = partpair;
150 for(ii = 0;ii<fNParticleFunctions;ii++)
151 fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
153 for(ii = 0;ii<fNTrackFunctions;ii++)
154 fTrackFunctions[ii]->ProcessSameEventParticles(tmptrackpair);
156 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
157 fParticleAndTrackFunctions[ii]->ProcessSameEventParticles(tmptrackpair,tmppartpair);
160 /***************************************/
161 /***** Filling denominators *********/
162 /***************************************/
164 tmppartpair->MirrorSecond();
165 tmptrackpair->MirrorSecond();
167 if((this->*fkPass)(tmppartpair,tmptrackpair) == kFALSE)
169 for(ii = 0;ii<fNParticleFunctions;ii++)
170 fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
172 for(ii = 0;ii<fNTrackFunctions;ii++)
173 fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
175 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
176 fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair,tmppartpair);
180 tmppartpair->DeleteSecond();
181 tmptrackpair->DeleteSecond();
183 //end of 2nd loop over particles from the same event
184 }//for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
186 //end of loop over particles from first event
187 }//for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
188 delete fPartBuffer->Push(partEvent1);
189 delete fTrackBuffer->Push(trackEvent1);
190 //end of loop over events
193 /*************************************************************************************/
195 Int_t AliHBTAnalysisStavinskyMixing::ProcessSim(AliAOD* /*aodrec*/, AliAOD* aodsim)
197 //Does analysis of simulated data
198 AliVAODParticle * part1, * part2;
200 AliAOD* partEvent = aodsim;
201 AliAOD* partEvent1 = new AliAOD();
206 AliHBTPair* partpair = &ppair;
208 AliHBTPair * tmppartpair;
215 Error("ProcessRecAndSim","Can not get event");
220 for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
222 /***************************************/
223 /****** Looping same events ********/
224 /****** filling numerators ********/
225 /***************************************/
226 Warning("ProcessTracksAndParticles","Non-std MIXING");
227 if ( (j%fDisplayMixingInfo) == 0)
228 Info("ProcessTracksAndParticles",
229 "Mixing particle %d with particles from the same event",j);
231 part1= partEvent->GetParticle(j);
233 Bool_t firstcut = fPairCut->GetFirstPartCut()->Rejected(part1);
235 if (fBufferSize != 0)
236 if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Rejected(part1) == kFALSE ) )
238 //accepted by any cut
239 // we have to copy because reader keeps only one event
241 partEvent1->AddParticle(part1);
244 if (firstcut) continue;
246 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
247 fParticleMonitorFunctions[ii]->Process(part1);
249 if ( fNParticleFunctions == 0 ) continue;
251 for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
253 part2= partEvent->GetParticle(k);
254 if (part1->GetUID() == part2->GetUID()) continue;
255 partpair->SetParticles(part1,part2);
257 if(fPairCut->Rejected(partpair)) //check pair cut
258 { //do not meets crietria of the
259 if( fPairCut->Rejected((AliHBTPair*)partpair->GetSwappedPair()) ) continue;
260 else tmppartpair = (AliHBTPair*)partpair->GetSwappedPair();
264 tmppartpair = partpair;
267 for(ii = 0;ii<fNParticleFunctions;ii++)
268 fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
271 /***************************************/
272 /***** Filling denominators *********/
273 /***************************************/
275 tmppartpair->MirrorSecond();
277 if(fPairCut->Rejected(partpair) == kFALSE)
279 for(ii = 0;ii<fNParticleFunctions;ii++)
280 fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
282 tmppartpair->DeleteSecond();
284 //end of 2nd loop over particles from the same event
285 }//for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
288 delete fPartBuffer->Push(partEvent1);
289 //end of loop over events
292 /*************************************************************************************/
293 Int_t AliHBTAnalysisStavinskyMixing::ProcessRec(AliAOD* aodrec, AliAOD* /*aodsim*/)
295 //Does analysis of reconstructed data
296 AliVAODParticle * track1, * track2;
298 AliAOD* trackEvent = aodrec;
299 AliAOD* trackEvent1 = new AliAOD();
305 AliHBTPair* trackpair = &tpair;
307 AliHBTPair * tmptrackpair;
314 Error("ProcessRecAndSim","Can not get event");
319 for (Int_t j = 0; j<trackEvent->GetNumberOfParticles() ; j++)
321 /***************************************/
322 /****** Looping same events ********/
323 /****** filling numerators ********/
324 /***************************************/
325 if ( (j%fDisplayMixingInfo) == 0)
326 Info("ProcessTracksAndParticles",
327 "Mixing Particle %d with Particles from the same event",j);
329 track1= trackEvent->GetParticle(j);
331 Bool_t firstcut = fPairCut->GetFirstPartCut()->Rejected(track1);
333 if (fBufferSize != 0)
334 if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Rejected(track1) == kFALSE ) )
336 //accepted by any cut
337 // we have to copy because reader keeps only one event
339 trackEvent1->AddParticle(track1);
342 if (firstcut) continue;
344 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
345 fParticleMonitorFunctions[ii]->Process(track1);
347 if ( fNParticleFunctions == 0 ) continue;
349 for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
351 track2= trackEvent->GetParticle(k);
352 if (track1->GetUID() == track2->GetUID()) continue;
353 trackpair->SetParticles(track1,track2);
355 if(fPairCut->Rejected(trackpair)) //check pair cut
356 { //do not meets crietria of the
357 if( fPairCut->Rejected((AliHBTPair*)trackpair->GetSwappedPair()) ) continue;
358 else tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
362 tmptrackpair = trackpair;
365 for(ii = 0;ii<fNTrackFunctions;ii++)
366 fParticleFunctions[ii]->ProcessSameEventParticles(tmptrackpair);
368 //end of 2nd loop over Particles from the same event
369 }//for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
371 /***************************************/
372 /***** Filling denominators *********/
373 /***************************************/
374 if (fBufferSize == 0) continue;
376 fTrackBuffer->ResetIter();
378 while (( trackEvent2 = fTrackBuffer->Next() ))
381 if ( (j%fDisplayMixingInfo) == 0)
382 Info("ProcessParticles",
383 "Mixing Particle %d from current event with Particles from event %d",j,-m);
384 for(Int_t l = 0; l<trackEvent2->GetNumberOfParticles();l++) // ... on all Particles
387 track2= trackEvent2->GetParticle(l);
388 trackpair->SetParticles(track1,track2);
390 if( fPairCut->Rejected(trackpair) ) //check pair cut
391 { //do not meets crietria of the
392 if( fPairCut->Rejected((AliHBTPair*)trackpair->GetSwappedPair()) )
396 tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
400 {//meets criteria of the pair cut
401 tmptrackpair = trackpair;
404 for(ii = 0;ii<fNTrackFunctions;ii++)
405 fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
407 }//for(Int_t l = 0; l<N2;l++) // ... on all Particles
410 delete fTrackBuffer->Push(trackEvent1);
411 //end of loop over events
414 /*************************************************************************************/
416 Int_t AliHBTAnalysisStavinskyMixing::ProcessRecAndSimNonId(AliAOD* aodrec, AliAOD* aodsim)
418 //Analyzes both reconstructed and simulated data
421 Error("ProcessTracksAndParticlesNonIdentAnal","Reconstructed event is NULL");
427 Error("ProcessTracksAndParticlesNonIdentAnal","Simulated event is NULL");
431 if ( aodrec->GetNumberOfParticles() != aodsim->GetNumberOfParticles() )
433 Error("ProcessTracksAndParticlesNonIdentAnal",
434 "Number of simulated particles (%d) not equal to number of reconstructed tracks (%d)",
435 aodsim->GetNumberOfParticles() , aodrec->GetNumberOfParticles());
440 AliVAODParticle * part1, * part2;
441 AliVAODParticle * track1, * track2;
443 static AliAOD aodrec1;
444 static AliAOD aodsim1;
446 AliAOD * trackEvent1=&aodrec1,*partEvent1=&aodsim1;//Particle that passes first particle cut, this event
447 trackEvent1->Reset();
449 AliAOD * trackEvent2=0x0,*partEvent2=0x0;//Particle that passes second particle cut, this event
450 AliAOD * trackEvent3=0x0,*partEvent3=0x0;//Particle that passes second particle cut, events from buffer
452 AliAOD* rawtrackEvent = aodrec;//this we get from Reader
453 AliAOD* rawpartEvent = aodsim;//this we get from Reader
455 static AliHBTPair tpair;
456 static AliHBTPair ppair;
458 AliHBTPair* trackpair = &tpair;
459 AliHBTPair* partpair = &ppair;
463 /********************************/
465 /********************************/
466 if ( ( (partEvent2==0x0) || (trackEvent2==0x0)) )//in case fBufferSize == 0 and pointers are created do not eneter
468 partEvent2 = new AliAOD();
469 trackEvent2 = new AliAOD();
472 FilterOut(partEvent1, partEvent2, rawpartEvent, trackEvent1, trackEvent2, rawtrackEvent);
474 for (Int_t j = 0; j<partEvent1->GetNumberOfParticles() ; j++)
476 if ( (j%fDisplayMixingInfo) == 0)
477 Info("ProcessTracksAndParticlesNonIdentAnal",
478 "Mixing particle %d from current event with particles from current event",j);
480 part1= partEvent1->GetParticle(j);
481 track1= trackEvent1->GetParticle(j);
484 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
485 fParticleMonitorFunctions[ii]->Process(part1);
486 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
487 fTrackMonitorFunctions[ii]->Process(track1);
488 for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
489 fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
491 if (fNoCorrfctns) continue;
493 /***************************************/
494 /****** filling numerators ********/
495 /****** (particles from event2) ********/
496 /***************************************/
498 for (Int_t k = 0; k < partEvent2->GetNumberOfParticles() ; k++) //partEvent1 and partEvent2 are particles from the same event but separated to two groups
500 part2= partEvent2->GetParticle(k);
501 if (part1->GetUID() == part2->GetUID()) continue;//this is the same particle but with different PID
502 partpair->SetParticles(part1,part2);
504 track2= trackEvent2->GetParticle(k);
505 trackpair->SetParticles(track1,track2);
507 if( (this->*fkPassPairProp)(partpair,trackpair) ) //check pair cut
508 { //do not meets crietria of the pair cut
512 {//meets criteria of the pair cut
513 for(ii = 0;ii<fNParticleFunctions;ii++)
514 fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
516 for(ii = 0;ii<fNTrackFunctions;ii++)
517 fTrackFunctions[ii]->ProcessSameEventParticles(trackpair);
519 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
520 fParticleAndTrackFunctions[ii]->ProcessSameEventParticles(trackpair,partpair);
524 if ( fBufferSize == 0) continue;//do not mix diff histograms
525 /***************************************/
526 /***** Filling denominators *********/
527 /***************************************/
528 fPartBuffer->ResetIter();
529 fTrackBuffer->ResetIter();
533 while ( (partEvent3 = fPartBuffer->Next() ) != 0x0)
535 trackEvent3 = fTrackBuffer->Next();
537 if ( (j%fDisplayMixingInfo) == 0)
538 Info("ProcessTracksAndParticlesNonIdentAnal",
539 "Mixing particle %d from current event with particles from event%d",j,-(++nmonitor));
541 for (Int_t k = 0; k < partEvent3->GetNumberOfParticles() ; k++)
543 part2= partEvent3->GetParticle(k);
544 partpair->SetParticles(part1,part2);
546 track2= trackEvent3->GetParticle(k);
547 trackpair->SetParticles(track1,track2);
549 if( (this->*fkPassPairProp)(partpair,trackpair) ) //check pair cut
550 { //do not meets crietria of the pair cut
554 {//meets criteria of the pair cut
556 for(ii = 0;ii<fNParticleFunctions;ii++)
557 fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
559 for(ii = 0;ii<fNTrackFunctions;ii++)
560 fTrackFunctions[ii]->ProcessDiffEventParticles(trackpair);
562 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
563 fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(trackpair,partpair);
565 }// for particles event2
567 }//for over particles in event1
569 delete fPartBuffer->Push(partEvent2);
570 delete fTrackBuffer->Push(trackEvent2);
574 /*************************************************************************************/
575 Int_t AliHBTAnalysisStavinskyMixing::ProcessSimNonId(AliAOD* /*aodrec*/, AliAOD* aodsim)
577 //does analysis of simulated (MC) data in non-identical mode
578 //i.e. when particles selected by first part. cut are a disjunctive set than particles
579 //passed by the second part. cut
586 AliVAODParticle * part1, * part2;
588 static AliAOD aodsim1;
590 AliAOD* partEvent1=&aodsim1;//Particle that passes first particle cut, this event
592 AliAOD* partEvent2=0x0;//Particle that passes second particle cut, this event
593 AliAOD* partEvent3=0x0;//Particle that passes second particle cut, events from buffer
595 AliAOD* rawpartEvent = aodsim;//this we get from Reader
597 static AliHBTPair ppair;
599 AliHBTPair* partpair = &ppair;
603 /********************************/
605 /********************************/
606 if (partEvent2==0x0)//in case fBufferSize == 0 and pointers are created do not eneter
608 partEvent2 = new AliAOD();
611 FilterOut(partEvent1, partEvent2, rawpartEvent);
613 for (Int_t j = 0; j<partEvent1->GetNumberOfParticles() ; j++)
615 if ( (j%fDisplayMixingInfo) == 0)
616 Info("ProcessParticlesNonIdentAnal",
617 "Mixing particle %d from current event with particles from current event",j);
619 part1= partEvent1->GetParticle(j);
622 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
623 fParticleMonitorFunctions[ii]->Process(part1);
625 if (fNParticleFunctions == 0) continue;
627 /***************************************/
628 /****** filling numerators ********/
629 /****** (particles from event2) ********/
630 /***************************************/
632 for (Int_t k = 0; k < partEvent2->GetNumberOfParticles() ; k++) //partEvent1 and partEvent2 are particles from the same event but separated to two groups
634 part2= partEvent2->GetParticle(k);
635 if (part1->GetUID() == part2->GetUID()) continue;//this is the same particle but with different PID
636 partpair->SetParticles(part1,part2);
639 if(fPairCut->PassPairProp(partpair) ) //check pair cut
640 { //do not meets crietria of the pair cut
644 {//meets criteria of the pair cut
645 for(ii = 0;ii<fNParticleFunctions;ii++)
646 fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
650 if ( fBufferSize == 0) continue;//do not mix diff histograms
651 /***************************************/
652 /***** Filling denominators *********/
653 /***************************************/
654 fPartBuffer->ResetIter();
658 while ( (partEvent3 = fPartBuffer->Next() ) != 0x0)
661 if ( (j%fDisplayMixingInfo) == 0)
662 Info("ProcessParticlesNonIdentAnal",
663 "Mixing particle %d from current event with particles from event%d",j,-(++nmonitor));
665 for (Int_t k = 0; k < partEvent3->GetNumberOfParticles() ; k++)
667 part2= partEvent3->GetParticle(k);
668 partpair->SetParticles(part1,part2);
671 if(fPairCut->PassPairProp(partpair) ) //check pair cut
672 { //do not meets crietria of the pair cut
676 {//meets criteria of the pair cut
677 for(ii = 0;ii<fNParticleFunctions;ii++)
679 fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
682 }// for particles event2
684 }//for over particles in event1
686 delete fPartBuffer->Push(partEvent2);
690 /*************************************************************************************/
691 Int_t AliHBTAnalysisStavinskyMixing::ProcessRecNonId(AliAOD* aodrec, AliAOD* /*aodsim*/)
693 //Analyzes both reconstructed and simulated data
699 AliVAODParticle * track1, * track2;
701 static AliAOD aodrec1;
702 AliAOD * trackEvent1=&aodrec1;//Particle that passes first particle cut, this event
703 trackEvent1->Reset();
704 AliAOD * trackEvent2=0x0;//Particle that passes second particle cut, this event
705 AliAOD * trackEvent3=0x0;//Particle that passes second particle cut, events from buffer
706 AliAOD* rawtrackEvent = aodrec;//this we get from Reader
708 static AliHBTPair tpair;
710 AliHBTPair* trackpair = &tpair;
715 /********************************/
717 /********************************/
718 if ( trackEvent2==0x0 )//in case fBufferSize == 0 and pointers are created do not eneter
720 trackEvent2 = new AliAOD();
723 FilterOut(trackEvent1, trackEvent2, rawtrackEvent);
725 for (Int_t j = 0; j<trackEvent1->GetNumberOfParticles() ; j++)
727 if ( (j%fDisplayMixingInfo) == 0)
728 Info("ProcessTracksNonIdentAnal",
729 "Mixing particle %d from current event with particles from current event",j);
731 track1= trackEvent1->GetParticle(j);
734 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
735 fTrackMonitorFunctions[ii]->Process(track1);
737 if (fNTrackFunctions == 0x0) continue;
739 /***************************************/
740 /****** filling numerators ********/
741 /****** (particles from event2) ********/
742 /***************************************/
744 for (Int_t k = 0; k < trackEvent2->GetNumberOfParticles() ; k++) //partEvent1 and partEvent2 are particles from the same event but separated to two groups
746 track2= trackEvent2->GetParticle(k);
747 if (track1->GetUID() == track2->GetUID()) continue;//this is the same particle but with different PID
748 trackpair->SetParticles(track1,track2);
751 if( fPairCut->PassPairProp(trackpair)) //check pair cut
752 { //do not meets crietria of the pair cut
756 {//meets criteria of the pair cut
758 for(ii = 0;ii<fNTrackFunctions;ii++)
759 fTrackFunctions[ii]->ProcessSameEventParticles(trackpair);
763 if ( fBufferSize == 0) continue;//do not mix diff histograms
764 /***************************************/
765 /***** Filling denominators *********/
766 /***************************************/
767 fTrackBuffer->ResetIter();
771 while ( (trackEvent3 = fTrackBuffer->Next() ) != 0x0)
773 if ( (j%fDisplayMixingInfo) == 0)
774 Info("ProcessTracksNonIdentAnal",
775 "Mixing particle %d from current event with particles from event%d",j,-(++nmonitor));
777 for (Int_t k = 0; k < trackEvent3->GetNumberOfParticles() ; k++)
779 track2= trackEvent3->GetParticle(k);
780 trackpair->SetParticles(track1,track2);
782 if( fPairCut->PassPairProp(trackpair)) //check pair cut
783 { //do not meets crietria of the pair cut
787 {//meets criteria of the pair cut
788 for(ii = 0;ii<fNTrackFunctions;ii++)
789 fTrackFunctions[ii]->ProcessDiffEventParticles(trackpair);
791 }// for particles event2
793 }//for over particles in event1
795 delete fTrackBuffer->Push(trackEvent2);
799 /*************************************************************************************/